yodata 0.0.1

package/README.md

@@ -0,0 +1,128 @@
+# Y0data services #
+
+**Please read y0data inc before using it**
+**To get database id go to https://data.y0host.net/**
+**Your data will save in servers y0data, so no disk will take from your server**
+
+# install y0data
+
+``` js
+npm install y0data
+```
+
+# Connect Database
+
+``` js
+let y0data = require('y0data')
+let db = new y0data('DATA BASE ID')
+db.connect();
+```
+
+# events
+
+```js
+db.once('ready', async ()=>{
+  console.log(`DataBase Ready`)
+})
+
+db.on('error', (err)=>{  
+  console.log(`Error: ` + err)
+})
+```
+
+# setup collection
+
+```js
+let customersDB = db.setUpCollection('customers')
+```
+
+# functions
+
+## Create
+```js
+let data = await customersDB.add([{"money": 51}, {"money": 9}]) // example output → '[Accepted Data]'
+let data = await customersDB.add({"_id": "123", "money": 5}) // example output → '{Accepted Data} / null'
+/*
+For free plan 50 array max in same time
+For Shared Plan 100 Array max in same time
+For Server Plan 500 Array max in same time
+*/
+```
+
+## find data
+```js
+let options = {
+$gte: {money: 10}, // Get Users have money low of 10
+$gt: {money: 50} // get Users have money more of 50
+$in: {_id: ['123', '1234']} // get Users have in same _id
+}
+
+let data = await customersDB.find(options).exec(); // example output → 'Array'
+let data = await customersDB.find(options).limit(20).exec(); // (Get Only 20 data) example output → 'Array'
+let data = await customersDB.find(options).skip(20).exec(); // (Skip first 20) example output → 'Array'
+let data = await customersDB.find(options).select({money: 1}).exec(); // (Will only see _id and money) example output → 'Array'
+let data = await customersDB.find(options).select({money: 0}).exec(); // (Will hide money) example output → 'Array'
+
+let data = await customersDB.findOne(options).exec(); // example output → 'Object/Null'
+let data = await customersDB.findOne(options).skip(20).exec(); // (Skip first 20) example output → 'Object/Null'
+let data = await customersDB.findOne(options).select({money: 1}).exec(); // (Will only see _id and money) example output → 'Object/Null'
+let data = await customersDB.findOne(options).select({money: 0}).exec(); // (Will hide money) example output → 'Object/Null'
+```
+
+## Update Data
+```js
+let options = {
+$gte: {money: 10}, // Get Users have money low of 10
+$gt: {money: 50} // get Users have money more of 50
+$in: {_id: ['123', '1234']} // get Users have in same _id
+}
+
+let new_values = {
+$inc: {money: 50}, // Add money you can also do -50 to remove
+
+$push: {arr: ["1"]}, // add in array items 
+$push: {arr: "1"}, // add in array item
+
+$pull: {arr: ["1"]}, // delete from array items
+$pull: {arr: "1"} // delete from array item
+}
+
+let data = await customersDB.updateOne(options, new_values) // example output → 'true/false' 
+
+let data = await customersDB.updateMany(options, new_values); // example output → 'true/false' (if update one only will return true always)
+```
+
+## Delete Data
+```js
+let options = {
+$gte: {money: 10}, // Get Users have money low of 10
+$gt: {money: 50} // get Users have money more of 50
+$in: {_id: ['123', '1234']} // get Users have in same _id
+}
+
+let data = await customersDB.deleteOne(options) // example output → 'true/false'
+
+let data = await customersDB.deleteMany(options); // example output → 'true/false' (if update one only will return true always)
+```
+
+## Other functions will support you
+```js
+let options = {
+$gte: {money: 10}, // Get Users have money low of 10
+$gt: {money: 50} // get Users have money more of 50
+$in: {_id: ['123', '1234']} // get Users have in same _id
+}
+
+let data = await customersDB.countDocuments(options) // example output → 'true/false'
+
+let data = await customersDB.getSize(options); // example output → 'true/false' (if update one only will return true always)
+```
+
+## Watch
+```js
+await cusotmersDB.watch()
+
+db.on('watch', (data)=>{
+    console.log('data watch =>', data) // will get name of collection and more data
+})
+```

package/data/collection.js

@@ -0,0 +1,156 @@
+let randomToken = require('random-token')
+let ws = require('../ws/index.js')
+let EventEmitter = require("events");
+  
+let create = async function (thi, collectionName){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "createCollection", data:{name: collectionName}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+  
+if(res.event === 'rejected') return null
+return true
+
+}
+
+let push = async function (thi, collectionName, options){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "create", data:{name: collectionName, options}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+  
+if(res.event === 'rejected') return null
+return res.data
+
+}
+
+let find = async function (thi, collectionName, options, select, limit, skip){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "find", data:{name: collectionName, options, select, limit, skip}, requestID}) }, 100)
+
+let res = (await thi.waitChunk(requestID))
+
+if(res.event === 'rejected') return null  
+
+return res.data
+
+}
+
+let findOne = async function (thi, collectionName, options, select, skip){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "findOne", data:{name: collectionName, options, select, skip}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+
+return res.data
+
+}
+
+let deleteOne = async function (thi, collectionName, options){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "deleteOne", data:{name: collectionName, options}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+
+return res.data
+
+}
+
+let deleteMany = async function (thi, collectionName, options){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "deleteMany", data:{name: collectionName, options}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+
+return res.data
+
+}
+
+let updateOne = async function (thi, collectionName, options, new_values){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "updateOne", data:{name: collectionName, options, new_values}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+return res.data
+
+}
+
+let updateMany = async function (thi, collectionName, options, new_values){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "updateMany", data:{name: collectionName, options, new_values}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+
+return res.data
+
+}
+
+let countDocuments = async function (thi, collectionName, options){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "countDocuments", data:{name: collectionName, options}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+
+return res.data || 0
+
+}
+
+let getSize = async function (thi, collectionName, options){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "getSize", data:{name: collectionName, options}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+  
+return res.data || 0
+
+}
+
+let watch = async function (thi, collectionName){
+  
+let requestID = randomToken(8)
+  
+setTimeout(()=>{ thi.project.createMessage({event: "watch", data:{name: collectionName}, requestID}) }, 100)
+
+let res = (await thi.waitResponse(requestID))
+
+if(res.event === 'rejected') return null  
+  
+return res.data || 0
+
+}
+
+module.exports = {create, push, find, findOne, deleteOne, deleteMany, updateOne, updateMany, countDocuments, getSize, watch};

package/data/plugin.js

@@ -0,0 +1,250 @@
+let randomToken = require('random-token')
+let ws = require('../ws/index.js')
+let EventEmitter = require("events");
+
+//console.log(manage.select([{must: true, love: true}, {must: true, love: false}], {love: 1}))
+let collection = require('../data/collection.js')
+
+ class Plugin extends EventEmitter {
+constructor (dataBaseID) {
+  super (dataBaseID)
+
+this.dataBaseID = dataBaseID
+this.project = new ws(`wss://y0data.glitch.me/?database_id=${this.dataBaseID}`)
+  
+process.plugin = this
+  
+}
+   
+ connect(){
+   
+  this.project.on('ready', ()=>{
+    this.emit('connect')
+  })
+  
+  this.project.on('disconnect', () =>{
+    this.emit('disconnect')
+        this.project.reconnectStatus = true
+  })
+  
+  this.project.on('message', (msg) =>{
+    
+    let data = msg.json()
+    
+//    console.log(data)
+    
+    if(data.event === 'ready'){
+    this.emit('ready')
+      
+    }
+    if(data.event === 'watchData'){
+      
+      if(data.requestID) return;
+      
+      this.emit('watch', data.data)
+            
+    }
+    if(data.event === 'error'){
+      
+      let errors = [{
+        num: 401,
+        message: "Failed Authorized with your database, please verify from id",
+        reconnect: false
+      }]
+      
+      let err = errors.find(x => x.num === data.data)
+            
+      if(!err?.reconnect){
+
+        this.project.reconnectStatus = false
+                
+      }else{
+        
+        this.project.reconnectStatus = true
+        
+      }
+      
+      this.emit('error', (err?.message || data.data))
+    }
+    
+  })
+  
+}
+   
+async waitResponse(requestID){
+return await new Promise(async re => {
+
+  let claimedMessage = (data)=>{
+    let msg = data.json()
+        
+    if(msg.requestID === requestID){
+      re(msg);
+      this.project.removeListener('message', claimedMessage)
+    }
+    
+  }
+  
+    this.project.on('message', (data)=>claimedMessage(data))
+    
+})
+}
+   
+async waitChunk(requestID){
+return await new Promise(async re => {
+
+  let result = '';
+    
+  let claimedMessage = (data)=>{
+    let msg = data.json()
+        
+    if(msg.requestID === requestID && msg.event === 'chunk'){
+//      re(msg);
+//      this.project.removeListener('message', claimedMessage)
+
+      result += msg.data
+      
+    }
+    
+    if(msg.requestID === requestID && msg.event === 'finish'){
+      
+      result += msg.data
+        
+      re({event: "accepted", data: JSON.parse(result)})
+      result = ''
+      this.project.removeListener('message', claimedMessage)
+      
+    }
+    
+  }
+  
+  
+    this.project.on('message', (data)=>claimedMessage(data))
+    
+})
+}
+   
+setUpCollection(collectionName){
+  //, withData, select
+let requestID = randomToken(8)
+  
+//setTimeout(()=>{ this.project.createMessage({event: "findCollection", data:{name: collectionName, withData: withData, select: select}, requestID}) }, 100)
+    
+//var response = await this.waitResponse(requestID)
+
+//let res = Array.isArray(response?.data) ? response?.data : [] || []
+
+let res = []
+
+res.add = async (options)=>{
+  return await collection.push(this, collectionName, options)
+}
+
+res.find = (options)=>{
+     
+  let query = {}
+  
+  var useSelect = null
+  let useLimit = null
+  let useSkip = null
+
+  query.select = (select)=>{    
+    useSelect = select
+    return query
+  }
+  
+  query.limit = (num)=>{
+    useLimit = num
+    return query
+  }
+  
+  query.skip = (num)=>{
+    useSkip = num
+    return query
+  }
+  
+  query.exec = ()=>{
+       return collection.find(this, collectionName, options, useSelect, useLimit, useSkip)  
+  }
+    
+  return query
+}
+
+res.findOne = (options, select)=>{
+     
+  let query = {}
+  
+  var useSelect = null
+  let useLimit = null
+  let useSkip = null
+
+  query.select = (select)=>{    
+    useSelect = select
+    return query
+  }
+  
+  query.limit = (num)=>{
+    useLimit = num
+    return query
+  }
+  
+  query.skip = (num)=>{
+    useSkip = num
+    return query
+  }
+  
+  query.exec = ()=>{
+       return collection.findOne(this, collectionName, options, useSelect, useSkip)  
+  }
+    
+  return query
+
+}
+
+res.deleteOne = (options)=>{
+  
+  return collection.deleteOne(this, collectionName, options)
+
+}
+
+res.deleteMany = (options)=>{
+  
+  return collection.deleteMany(this, collectionName, options)
+
+}
+
+res.updateOne = (options, new_values)=>{
+  
+  return collection.updateOne(this, collectionName, options, new_values)
+
+}
+
+res.updateMany = (options, new_values)=>{
+  
+  return collection.updateMany(this, collectionName, options, new_values)
+
+}
+
+res.countDocuments = (options)=>{
+  
+  return collection.countDocuments(this, collectionName, options)
+
+}
+
+res.size = (options)=>{
+  
+  return collection.getSize(this, collectionName, options)
+
+}
+
+res.watch = ()=>{
+  
+  return collection.watch(this, collectionName)
+
+}
+
+  return res
+  
+}
+
+ }
+module.exports = Plugin;

package/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "yodata",
+    "description": "Y0data online services to save your data",
+    "version": "0.0.1",
+    "main": "data/plugin.js",
+    "dependencies": {
+        "events": "^3.3.0",
+        "random-token": "^0.0.8",
+        "ws": "^8.16.0"
+    },
+    "keywords": [
+        "database",
+        "data",
+        "y0data"
+    ],
+    "author": "Yousuf",
+    "license": "BSD-2-Clause",
+    "readmeFilename": "README.md"
+}

package/ws/Message.js

@@ -0,0 +1,18 @@
+class Message extends Object {
+    constructor (message) {
+      super  ()
+    this.body = message
+    }
+    
+    json(){
+    try { return JSON.parse(this.body) } catch(e) { return e.message };
+    }
+    
+    text(){
+    if(this.body.includes('Buffer')) return Buffer.from(this.body).toString("utf8")
+    return this.body
+    }
+    
+}
+module.exports = Message
+    

package/ws/index.js

@@ -0,0 +1,195 @@
+let EventEmitter = require("events");
+const ws = require('ws')
+let Message = require('../ws/Message.js')
+
+ class index extends EventEmitter {
+constructor (url, options) {
+  super  ()
+this.headers = {}
+if(!options) options = {}
+if(options.headers) this.headers = options.headers
+  
+this.eventSendMessage = options.sendMessage
+  
+if(options.sendMessage) {
+if(options.sendMessage.on) this.eventSendMessage = options.sendMessage.on
+}
+  
+this.options = options
+this.url = url
+this.pingStatus = false
+this.project = null
+this.autosendStatus = false
+this.historyPing = []
+this.historySend = []
+this.autoSend = {time: 10, msg: {"event": "hello", data: {world: true}}}
+this.pingOptions = {time: 35, msg: {"event": "ping", data: {}}}
+this._messages = []
+this.cache =  true
+
+this.ready = false
+
+  if(options.cache === false) this.cache = false
+this.reconnectStatus = options.reconnect || false
+  this._catchSystem()
+this._connect(url, this.headers, options)
+
+}
+
+ _catchSystem(){
+setInterval(async ()=>{
+if(this.cache === true) return;
+this._messages = []
+for(const d of this.historyPing.filter(data => data.use === true)) this.historyPing.shift(d)
+for(const d of this.historySend.filter(data => data.use === true)) this.historySend.shift(d)
+
+}, 500)
+}
+
+ _ready(){
+this.emit("ready")
+}
+
+async _close(a1, a2, a3){
+  await this.disablePing()
+this.emit('disconnect', a1, a2)
+this.ready = false
+if(this.reconnectStatus === true) this.reconnect()
+}
+
+ _error(a1, a2, a3){
+//this.emit('error', a1, a2)
+}
+
+ _eventCreateMessage(a1){
+this.emit('createMessage', a1)
+}
+
+ _eventReConnect(){
+this.emit('reConnect')
+}
+
+ _ping(message){
+this.emit('ping', message)
+}
+
+
+async createMessage(msg){
+
+let data; try { data = JSON.parse(JSON.stringify(msg)) } catch(e) {this._messages.unshift({json: null, text: msg}); return new Message(msg) };
+try { 
+await this.project.send(JSON.stringify(msg))
+this._messages.unshift({json: JSON.parse(JSON.stringify(msg)), text: msg})
+  
+this.emit(this.eventSendMessage, new Message(JSON.stringify(msg)))
+  
+return new Message(JSON.stringify(msg))
+} catch(e) { 
+return e.message
+}
+}
+
+ _message(msg){
+try { this._messages.unshift({json: JSON.parse(msg), text: msg})} catch { this._messages.unshift({json: null, text: msg}) };
+this.emit('message', new Message(msg)) 
+}
+
+async disconnect(){
+ await this.project.close()
+return {url: this.url, headers: this.headers, options: this.options}
+}
+
+ systemAutoSend(id){
+this.historySend.unshift({id: id, use: false, send: null})
+let d = this.historySend.find(a => a.id === id)
+setInterval(async ()=>{
+if(d.use === true) return;
+this.systemAutoSend(this.historySend.length + 1);
+d.use = true
+if(this.autosendStatus === false) return d.send = false;
+this.event('autoSend', this.autoSend.msg)
+this.createMessage(this.autoSend.msg)
+d.send = true
+}, this.autoSend.time * 1000)
+return {status: this.autosendStatus, options: this.autoSend, dataConnect: d}
+}
+   
+ systemPing(id){
+this.historyPing.unshift({id: id, use: false, send: null})
+let d = this.historyPing.find(a => a.id === id)
+setInterval(async ()=>{
+if(d.use === true) return;
+this.systemPing(this.historyPing.length + 1);
+d.use = true
+if(this.pingStatus === false) return d.send = false;
+this.event('ping', this.pingOptions.msg)
+this.createMessage(this.pingOptions.msg)
+d.send = true
+}, this.pingOptions.time * 1000)
+return {status: this.pingStatus, options: this.pingOptions, dataConnect: d}
+}
+
+   
+ enableAutoSend(options){
+if(options) this.autoSend = options
+this.autosendStatus = true
+this.systemAutoSend(this.historySend.length + 1)
+return {status: this.autosendStatus, options: this.autoSend}
+}
+
+ disableAutoSend(){
+this.autosendStatus = false
+return {status: this.autosendStatus, options: this.autoSend}
+}
+ enablePing(options){
+if(options) this.pingOptions = options
+this.pingStatus = true
+this.systemPing(this.historyPing.length + 1)
+return {status: this.pingStatus, options: this.pingOptions}
+}
+
+ disablePing(){
+this.pingStatus = false
+return {status: this.pingStatus, options: this.pingOptions}
+}
+
+async reconnect(time){
+    return await new Promise(re => {
+if(!time){
+if(this.options && this.options.reconnectTime) {time = this.options.reconnectTime}else{time = 2}
+}
+  
+  setTimeout(()=>{
+this.event('reconnect')
+this._connect(this.url, this.headers, this.options)
+re({url: this.url, headers: this.headers, options: this.options})
+    }, time * 1000)
+    })
+}
+
+ event(d1, d2, d3){
+if(d1 === "open") this._ready()
+if(d1 === "close") this._close(d2, d3)
+if(d1 === "error") this._error(d2, d3)
+if(d1 === "message") this._message(d2)
+if(d1 === "createmessage") this._eventCreateMessage(d2)
+if(d1 === "reconnect") this._eventReConnect()
+if(d1 === "ping") this._ping(d1)
+
+return {dataOne: d1, dataTwo: d2, dataThree: d3}
+
+}
+
+ _connect(url, headers, options){
+this.project = new ws( url , options.protocol || options._protocol , { headers:this.headers })
+this.ready=true
+this.project.on('open', async (open) => {this.event('open')});
+this.project.on('message', async (msg) => { this.event('message', msg) })
+this.project.on('close', async (d1, d2) => {this.event('close', d1, d2)});
+this.project.on('error', async (d1, d2) => {this.event('error', d1, d2);});
+return {url: url, headers: headers, options: options}
+}
+
+
+ }
+module.exports = index