devcode-canavar-pro 3.3.0

package/lib/Collection.js

@@ -0,0 +1,295 @@
+const path = require('path');
+const crypto = require('crypto');
+const EventEmitter = require('events');
+const Journal = require('./Journal');
+const QueryParser = require('./QueryParser');
+const UpdateParser = require('./UpdateParser');
+const Index = require('./Index');
+const Middleware = require('./Middleware');
+const Cache = require('./Cache');
+const Storage = require('./Storage');
+
+/**
+ * Collection Class
+ * Veri ekleme, silme, güncelleme ve sorgulama işlemlerini yönetir.
+ */
+class Collection extends EventEmitter {
+    constructor(name, dbPath) {
+        super();
+        this.name = name;
+        this.dbPath = dbPath;
+        this.filePath = path.join(dbPath, `${name}.devcode`);
+        this.journal = new Journal(dbPath);
+        this.middleware = new Middleware();
+        this.cache = new Cache(5000); // 5000 dökümanlık hızlı bellek
+        this.schema = null;
+        this.indexes = new Map();
+        this.queryStats = new Map(); // Auto-indexing için istatistikler
+        this.data = [];
+        this.transactionData = null;
+        this._load();
+    }
+
+    /**
+     * Koleksiyon için şema belirler.
+     */
+    setSchema(schemaInstance) {
+        this.schema = schemaInstance;
+    }
+
+    /**
+     * Middleware kancası ekler.
+     */
+    pre(action, fn) { this.middleware.pre(action, fn); }
+    post(action, fn) { this.middleware.post(action, fn); }
+
+    /**
+     * Belirli bir alan için indeks oluşturur.
+     */
+    createIndex(field) {
+        const index = new Index(this.name, field, this.dbPath);
+        this.indexes.set(field, index);
+
+        // Mevcut verileri indeksle
+        this.data.forEach(doc => {
+            if (doc[field]) index.add(doc[field], doc._id);
+        });
+    }
+
+    /**
+     * Veriyi diskten yükler.
+     * @private
+     */
+    _load() {
+        try {
+            this.data = Storage.load(this.filePath);
+            // Cache'e at
+            this.data.forEach(doc => this.cache.set(doc._id, doc));
+        } catch (err) {
+            console.error(`Koleksiyon yükleme hatası (${this.name}):`, err);
+            this.data = [];
+        }
+    }
+
+    /**
+     * Veriyi diske kaydeder.
+     * @private
+     */
+    _save() {
+        Storage.save(this.filePath, this.data);
+    }
+
+    /**
+     * Döküman ekler.
+     * @param {Object} doc 
+     */
+    async insert(doc) {
+        // 1. Şema Doğrulama
+        if (this.schema) this.schema.validate(doc);
+
+        // 2. Pre-Insert Middleware
+        await this.middleware.runPre('insert', doc);
+
+        this.journal.lock();
+        try {
+            const newDoc = {
+                _id: crypto.randomBytes(12).toString('hex'),
+                ...doc,
+                createdAt: new Date()
+            };
+
+            // Günlüğe kaydet
+            await this.journal.record(this.name, 'INSERT', newDoc);
+
+            // Veriyi ekle (Transaction varsa oraya, yoksa ana veriye)
+            const target = this.transactionData || this.data;
+            target.push(newDoc);
+
+            // İndeksleri güncelle (Sadece transaction yoksa veya commit edilince)
+            if (!this.transactionData) {
+                this._save();
+                this.indexes.forEach((idx, field) => {
+                    if (newDoc[field]) idx.add(newDoc[field], newDoc._id);
+                });
+            }
+
+            // 3. Olay Yayınla (Real-time)
+            this.emit('insert', newDoc);
+            this.emit('change', { type: 'INSERT', data: newDoc });
+
+            // 4. Post-Insert Middleware
+            await this.middleware.runPost('insert', newDoc);
+
+            return newDoc;
+        } finally {
+            this.journal.unlock();
+        }
+    }
+
+    /**
+     * Toplu döküman ekler (Ultra Hızlı).
+     * @param {Object[]} docs 
+     */
+    async insertMany(docs) {
+        if (!Array.isArray(docs)) throw new Error('Dizi gönderilmelidir.');
+
+        this.journal.lock();
+        try {
+            const added = [];
+            for (let doc of docs) {
+                if (this.schema) this.schema.validate(doc);
+                const newDoc = {
+                    _id: crypto.randomBytes(12).toString('hex'),
+                    ...doc,
+                    createdAt: new Date()
+                };
+                added.push(newDoc);
+
+                // Toplu işlemde cache ve data güncelle
+                this.data.push(newDoc);
+                this.cache.set(newDoc._id, newDoc);
+
+                this.indexes.forEach((idx, field) => {
+                    if (newDoc[field]) idx.add(newDoc[field], newDoc._id);
+                });
+            }
+
+            await this.journal.record(this.name, 'INSERT_MANY', { count: docs.length });
+            this._save();
+            this.emit('insertMany', added);
+            return added;
+        } finally {
+            this.journal.unlock();
+        }
+    }
+
+    /**
+     * Gelişmiş sorgu motorunu kullanarak arama yapar.
+     * (Eğer indeks varsa indeks üzerinden hızlandırır)
+     */
+    find(query = {}) {
+        // 1. İndeks Kullanımı (Eğer tek bir alan üzerinden basit eşitlik aranıyorsa)
+        const queryFields = Object.keys(query);
+
+        // Eğer tek bir basit sorgu varsa ve indeksi varsa kullan
+        if (queryFields.length === 1 && typeof query[queryFields[0]] !== 'object') {
+            const field = queryFields[0];
+            const val = query[field];
+
+            if (this.indexes.has(field)) {
+                const ids = this.indexes.get(field).get(val);
+                return this.data.filter(item => ids.includes(item._id));
+            }
+
+            // İstatistik tut (Eğer çok sorgulanıyorsa otomatik indeksle)
+            this.queryStats.set(field, (this.queryStats.get(field) || 0) + 1);
+            if (this.queryStats.get(field) > 100) { // 100 sorguda bir indeks oluştur
+                console.log(`🚀 [Auto-Index] '${field}' alanı çok sorgulanıyor, indeksleniyor...`);
+                this.createIndex(field);
+                this.queryStats.set(field, -999999); // Tekrar tetiklenme
+            }
+        }
+
+        return this.data.filter(item => QueryParser.matches(item, query));
+    }
+
+    /**
+     * Tek bir döküman bulur.
+     */
+    findOne(query = {}) {
+        const results = this.find(query);
+        return results.length > 0 ? results[0] : null;
+    }
+
+    /**
+     * Dökümanları günceller ($set, $inc, $push vb. destekler).
+     * @param {Object} query Filtreleme sorgusu
+     * @param {Object} updateQuery Güncelleme operatörleri
+     */
+    async update(query, updateQuery) {
+        const targets = this.find(query);
+        if (targets.length === 0) return 0;
+
+        await this.middleware.runPre('update', { query, updateQuery });
+
+        targets.forEach(doc => {
+            UpdateParser.parse(doc, updateQuery);
+            doc.updatedAt = new Date();
+            this.cache.set(doc._id, doc);
+        });
+
+        this._save();
+        await this.journal.record(this.name, 'UPDATE', { query, count: targets.length });
+
+        await this.middleware.runPost('update', targets);
+        this.emit('update', targets);
+        return targets.length;
+    }
+
+    /**
+     * Tek bir dökümanı günceller.
+     */
+    async updateOne(query, updateQuery) {
+        const doc = this.findOne(query);
+        if (!doc) return false;
+
+        UpdateParser.parse(doc, updateQuery);
+        doc.updatedAt = new Date();
+        this.cache.set(doc._id, doc);
+
+        this._save();
+        await this.journal.record(this.name, 'UPDATE_ONE', { id: doc._id });
+        return true;
+    }
+
+    /**
+     * Verileri siler.
+     */
+    async remove(query = {}) {
+        const initialLength = this.data.length;
+        const toDeleteIDs = this.data
+            .filter(item => QueryParser.matches(item, query))
+            .map(item => item._id);
+
+        if (toDeleteIDs.length === 0) return 0;
+
+        await this.middleware.runPre('remove', query);
+
+        this.data = this.data.filter(item => !toDeleteIDs.includes(item._id));
+        toDeleteIDs.forEach(id => this.cache.del(id));
+
+        this._save();
+        await this.journal.record(this.name, 'REMOVE', { query, count: toDeleteIDs.length });
+
+        await this.middleware.runPost('remove', toDeleteIDs);
+        this.emit('remove', toDeleteIDs);
+        return toDeleteIDs.length;
+    }
+
+    // --- TRANSACTION DESTEĞİ ---
+
+    startTransaction() {
+        this.transactionData = JSON.parse(JSON.stringify(this.data));
+    }
+
+    commitTransaction() {
+        if (this.transactionData) {
+            this.data = this.transactionData;
+            this.transactionData = null;
+            this._save();
+            // İndeksleri sıfırla ve yeniden oluştur
+            this.indexes.forEach((idx, field) => {
+                idx.clear();
+                this.data.forEach(doc => {
+                    if (doc[field]) idx.add(doc[field], doc._id);
+                });
+            });
+        }
+    }
+
+    abortTransaction() {
+        this.transactionData = null;
+    }
+}
+
+module.exports = Collection;

package/lib/Core.js

@@ -0,0 +1,164 @@
+const fs = require('fs');
+const path = require('path');
+const Database = require('./Database');
+const Dashboard = require('./Dashboard');
+const CLI = require('./CLI');
+const BackupService = require('./BackupService');
+const Server = require('./Server');
+
+/**
+ * DevCode Core Manager
+ * Veritabanı yönetiminden sorumlu ana sınıf.
+ */
+class DevCode {
+  constructor(options = {}) {
+    this.dataPath = options.dataPath || path.join(process.cwd(), 'data');
+    this.databases = new Map();
+    this._backup = null;
+
+    // Veri klasörünü oluştur
+    if (!fs.existsSync(this.dataPath)) {
+      fs.mkdirSync(this.dataPath, { recursive: true });
+    }
+
+    // Otomatik Güncelleme Kontrolü
+    this.checkUpdate();
+
+    // Otomatik Yedekleme (VDS için önerilir)
+    if (options.backup) {
+      const backupOpts = typeof options.backup === 'object' ? options.backup : {};
+      this._backup = new BackupService(this.dataPath, backupOpts);
+      this._backup.start();
+    }
+
+    // Otomatik Dashboard Başlatma
+    if (options.dashboard) {
+      this.startDashboard(options.port || 3000);
+    } else {
+      console.log(`\x1b[32m[DevCode]\x1b[0m Monster v2.0 aktif. Görsel panel için: \x1b[4m{ dashboard: true }\x1b[0m`);
+    }
+  }
+
+  /**
+   * NPM üzerinden sürüm kontrolü yapar.
+   */
+  async checkUpdate() {
+    try {
+      const https = require('https');
+      const pkg = require('../package.json');
+
+      https.get(`https://registry.npmjs.org/${pkg.name}/latest`, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            const latest = JSON.parse(data).version;
+            if (latest !== pkg.version) {
+              console.log(`\n\x1b[33m[!] YENİ GÜNCELLEME SİNYALİ:\x1b[0m v${pkg.version} -> \x1b[32mv${latest}\x1b[0m`);
+              console.log(`\x1b[33m[!] Güncellemek için:\x1b[0m npm i ${pkg.name}@latest\n`);
+            }
+          } catch (e) { }
+        });
+      }).on('error', () => { });
+    } catch (e) { }
+  }
+
+  /**
+   * Bir veritabanına bağlanır veya yoksa oluşturur.
+   * @param {string} dbName Veritabanı adı
+   * @param {string} namespace İsteğe bağlı namespace (VDS Multi-tenancy için)
+   * @returns {Database} Veritabanı örneği
+   */
+  use(dbName, namespace = null) {
+    if (!dbName || typeof dbName !== 'string') {
+      throw new Error('Geçersiz veritabanı adı.');
+    }
+
+    const fullDbName = namespace ? `${namespace}/${dbName}` : dbName;
+
+    if (this.databases.has(fullDbName)) {
+      return this.databases.get(fullDbName);
+    }
+
+    const dbPath = path.join(this.dataPath, fullDbName);
+    const db = new Database(dbName, dbPath);
+    this.databases.set(fullDbName, db);
+
+    return db;
+  }
+
+  /**
+   * Mevcut veritabanlarını listeler.
+   * @param {string} namespace - Opsiyonel, sadece bu namespace içindeki DB'leri listeler.
+   * @returns {string[]} Veritabanı isimleri
+   */
+  listDatabases(namespace = null) {
+    const searchPath = namespace ? path.join(this.dataPath, namespace) : this.dataPath;
+    if (!fs.existsSync(searchPath)) return [];
+    return fs.readdirSync(searchPath)
+      .filter(file => {
+        try {
+          return fs.statSync(path.join(searchPath, file)).isDirectory();
+        } catch (e) {
+          return false;
+        }
+      });
+  }
+
+  /**
+   * Bir veritabanını tamamen siler.
+   * @param {string} dbName Silinecek veritabanı adı
+   */
+  dropDatabase(dbName) {
+    const dbPath = path.join(this.dataPath, dbName);
+    if (fs.existsSync(dbPath)) {
+      fs.rmSync(dbPath, { recursive: true, force: true });
+      this.databases.delete(dbName);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * BackupService örneğine erişim sağlar.
+   * @returns {BackupService}
+   */
+  get backup() {
+    if (!this._backup) {
+      throw new Error("Yedekleme servisi aktif değil. DevCode()'u { backup: true } ile başlatın.");
+    }
+    return this._backup;
+  }
+
+  /**
+   * Uzak bağlantı sunucusunu başlatır (VDS için).
+   * Kullanıcılar RemoteClient ile bu sunucuya bağlanabilir.
+   * @param {object} options
+   * @param {number} options.port   - Port numarası (varsayılan: 4242)
+   * @param {string} options.secret - Güvenlik anahtarı
+   * @returns {Server}
+   */
+  startServer(options = {}) {
+    const server = new Server(this, options);
+    server.start();
+    return server;
+  }
+
+  /**
+   * Görsel Dashboard'u başlatır.
+   */
+  startDashboard(port = 3000) {
+    const dash = new Dashboard(this, port);
+    dash.start();
+  }
+
+  /**
+   * İnteraktif Shell'i (CLI) başlatır.
+   */
+  startShell() {
+    const shell = new CLI(this);
+    shell.start();
+  }
+}
+
+module.exports = DevCode;