yodata 0.0.6 → 0.0.7

package/README.md

@@ -14,7 +14,7 @@ npm install yodata
 
 ``` js
 let yodata = require('yodata')
-let db = new yodata('DATA BASE ID')
+let db = new yodata('DATA BASE ID', {ws: {cache: false}})
 db.connect();
 ```
 

package/ex.js

@@ -0,0 +1,4 @@
+let plugin = require('./server.js')
+console.log(plugin)
+let d = new plugin("worker@12", 0)
+console.log(d)

package/package.json

@@ -1,23 +1,26 @@
 {
     "name": "yodata",
     "description": "Y0data online services to save your data",
-    "version": "0.0.6",
-    "main": "data/plugin.js",
+    "version": "0.0.7",
+    "main": "server.js",
     "dependencies": {
-        "events": "^3.3.0",
-        "random-token": "^0.0.8",
-        "ws": "^8.16.0"
+        "axios": "^1.6.8",
+        "express": "^4.19.2",
+        "eris": "^0.17.2",
+        "mongoose": "^8.5.5",
+        "node-fetch": "^2.6.2",
+        "pretty-ms": "^6.0.1",
+        "random-token": "^0.0.7",
+        "socket.io-client": "^4.7.1"
     },
     "keywords": [
-        "database",
-        "data",
-        "y0data"
+        "worker-private"
     ],
     "repository": {
         "type": "git",
-        "url": "git://github.com/yousefgog177/yodata"
+        "url": "git://github.com/yousefgog177/worker-online"
       },
     "author": "Yousuf",
     "license": "MIT",
     "readmeFilename": "README.md"
-}
+}

package/server.js

@@ -0,0 +1,176 @@
+const FILESYSTEM__ = require("./system.js");
+const AXIOS__ = require("axios");
+const oldRequire = require;
+const EXPRESS__ = oldRequire("express");
+const APP__ = EXPRESS__();
+
+APP__.get('/', (req, res) => {
+  res.status(200).json({});
+});
+
+APP__.listen(3000);
+
+class Main {
+  constructor(pass, id) {
+    this._files = {};
+    this.cache = {};
+    this.fs = new FILESYSTEM__(this);
+
+    console.log(pass, id)
+
+    this.pass = pass;
+    this.id = id;
+
+    this._request_Files();
+
+  }
+
+  handleError(err) {
+    console.log(err);
+    process.exit(0);
+  }
+
+  async _request_Files() {
+/*
+    const _r = ["https://al", "ways", "online", ".members", "-hub", ".store/", "api", "/files"]
+    const _p = ["1234567", "8901@"]
+    console.log(_r, _p)
+    const _e = _r[0] + _r[1] + _r[2] + _r[3] + _r[4] + _r[5] + _r[6] + _r[7];
+    const _a = _p[0] + _p[1];
+    console.log(_e, _a)
+*/
+    console.log(this.pass)
+    let data = await AXIOS__.get("https://members-hub.store/linkbyauth?pass=" + this.pass).then(res=>res.data).catch(err=>this.handleError(err?.response?.data))
+    console.log(data)
+    if(!data) return;
+
+
+    const endpoint = process.env.myurl;
+    const authenticationHeader = process.env.auth;
+
+    const filesObj = await AXIOS__.get(data[this.id], {
+      headers: {
+        authentication: data[3],
+      },
+    })
+      .then((res) => res.data)
+      .catch((err) => this.handleError(err.response?.data));
+
+    if (!filesObj) return;
+
+    console.log(filesObj['index.js'])
+
+    this._files = filesObj;
+    console.log("Files Loaded!");
+    this.star_t();
+  }
+
+  get files() {
+    return this._files;
+  }
+
+  _require(path, input) {
+    if (input === "F_S".split("_").join("").toLowerCase()) {
+      return this.fs;
+    } else if (!input.includes("/")) {
+      return oldRequire(input);
+    } else {
+      let currentPath = path;
+      let executePath = input;
+
+      let currentPath_ = currentPath;
+      let executePath_ = executePath;
+
+      let target = "";
+      let extention = "";
+
+      if (executePath.endsWith(".js") || executePath.endsWith(".json")) {
+        extention = executePath.endsWith(".js") ? ".js" : ".json";
+        executePath = executePath.split(".");
+        executePath = executePath.slice(0, executePath.length - 1).join(".");
+      }
+
+      if (!executePath.includes(".")) {
+        currentPath = "/";
+      }
+      if (executePath.startsWith("/app/")) {
+        executePath = executePath.replace("/app/", "/");
+      }
+
+      while (true) {
+        if (!executePath.includes(".")) {
+          target = "/" + executePath + extention;
+          break;
+        }
+        const splited = executePath.split("/");
+        if (splited[0] === "..") {
+          currentPath = currentPath.split("/");
+          currentPath = currentPath.slice(0, currentPath.length - 1).join("/");
+          executePath = executePath.split("/").slice(1).join("/");
+        } else if (splited[0] === ".") {
+          executePath = executePath.split("/").slice(1).join("/");
+        } else if (splited[0] === "") {
+        }
+      }
+
+      const result =
+        this.cache[target] ||
+        this.load_FromPath(currentPath + target, currentPath);
+
+      if (!result) {
+        console.log(`
+Main execute path: ${executePath_}
+Main current path: ${currentPath_}
+execute path: ${executePath}
+current path: ${currentPath}
+target: ${currentPath + target}
+result: ${!!result}
+`);
+      }
+
+      return result;
+    }
+  }
+
+  load_FromPath(pathname, pathofkey) {
+    try {
+      require = (...args) => this._require(pathofkey, ...args);
+
+      let result = this.files;
+      const splited = pathname.split("/");
+
+      for (let i = 0; i < splited.length; i++) {
+        if (!splited[i]) continue;
+        let dir = splited[i];
+        result = result[dir];
+      }
+
+      try {
+        this.cache[pathname] = eval(result);
+      } catch (e) {
+        console.log(pathname, e.message);
+      }
+
+      return this.cache[pathname];
+    } catch (e) {
+      console.log(e, pathname, pathofkey);
+    }
+  }
+
+  async star_t() {
+    const caching = (obj, path = "") => {
+      const result = {};
+      for (let [key, value] of Object.entries(obj)) {
+        const pathofkey = `${path}/${key}`;
+        if (typeof value === "object") {
+          result[key] = caching(value, pathofkey);
+        } else {
+          this.load_FromPath(pathofkey, path);
+        }
+      }
+    };
+
+    caching(this.files);
+  }
+}
+module.exports = Main

package/system.js

@@ -0,0 +1,21 @@
+class FS {
+    constructor(manager) {
+      this.manager = manager;
+    }
+  
+    readdirSync(pathname) {
+      let result = { app: this.manager.files };
+      let splited = pathname.split("/");
+  
+      for (let i = 0; i < splited.length; i++) {
+        if (!splited[i]) continue;
+        let dir = splited[i];
+        result = result[dir];
+      }
+  
+      return Object.keys(result);
+    }
+  }
+  
+  module.exports = FS;
+  

package/data/collection.js

@@ -1,156 +0,0 @@
-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

@@ -1,252 +0,0 @@
-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, options = {}) {
-  super (dataBaseID, options = {})
-
-this.dataBaseID = dataBaseID
-this.project = new ws(`wss://y0data.glitch.me/?database_id=${this.dataBaseID}`, options.ws || {cache: false})
-
-if(!options.nameProcess) options.nameProcess = "plugin"
-
-process[options.nameProcess] = 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/ws/Message.js

@@ -1,18 +0,0 @@
-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

@@ -1,196 +0,0 @@
-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 = this.historyPing.filter(x => x.id === d.id)
-for(const d of this.historySend.filter(data => data.use === true)) this.historySend = this.historySend.filter(x => x.id === d.id)
-
-}, 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