devcode-canavar-pro 3.3.0

package/lib/RemoteClient.js

@@ -0,0 +1,275 @@
+const http = require('http');
+
+// Baran'ın Merkezi Veri Sunucusu (VDS) - Veri Merkezi IP
+const CLOUD_HOST = '45.74.244.192';
+const CLOUD_PORT = 4242;
+
+/**
+ * DevCode Remote Client
+ * VDS'teki DevCode Server'a uzaktan bağlanır.
+ * API, yerel Collection ile birebir aynıdır.
+ */
+class RemoteClient {
+    /**
+     * @param {string|object} options - Connection URI string or options object
+     */
+    constructor(options = {}) {
+        let uri = typeof options === 'string' && options.startsWith('devcode:') ? options : (options.uri || process.env.DEVCODE_URI);
+        let host, port, secret;
+
+        if (uri) {
+            try {
+                const url = new URL(uri);
+                secret = url.username || null;
+                host = url.hostname;
+                port = parseInt(url.port) || CLOUD_PORT;
+            } catch (e) {
+                throw new Error("Geçersiz Connection URI! Format: devcode://secret@vds-ip:4242");
+            }
+        } else {
+            // Varsayılan olarak Baran'ın Bulut Sunucusuna bağlan
+            host = options.host || process.env.DEVCODE_HOST || CLOUD_HOST;
+            port = options.port || process.env.DEVCODE_PORT || CLOUD_PORT;
+            secret = typeof options === 'string' ? options : (options.secret || null);
+        }
+
+        this.host = host;
+        this.port = port;
+        this.secret = secret;
+        this.timeout = options.timeout || 10000;
+        this.maxRetries = options.maxRetries || 3; // Varsayılan 3 deneme
+        this.retryDelay = options.retryDelay || 1000; // Denemeler arası 1 saniye
+        this._dashboard = null;
+    }
+
+    /**
+     * Kullanıcının kendi verilerini yönetebilmesi için yerel paneli başlatır.
+     * Bu panel VDS'teki verileri gösterir!
+     */
+    startDashboard(port = 3000) {
+        const Dashboard = require('./Dashboard');
+        this._dashboard = new Dashboard(this, port);
+        this._dashboard.start();
+    }
+
+    /**
+     * Bağlantıyı test eder.
+     * @returns {Promise<boolean>}
+     */
+    async ping() {
+        const res = await this._request('GET', '/ping');
+        return res.ok === true;
+    }
+
+    /**
+     * Uzak sunucudaki veritabanı listesini getirir.
+     * @returns {Promise<string[]>}
+     */
+    async listDatabases() {
+        const res = await this._request('GET', '/databases');
+        return res.data || [];
+    }
+
+    /**
+     * Bir veritabanına bağlanır.
+     * @param {string} dbName
+     * @returns {RemoteDatabase}
+     */
+    use(dbName) {
+        return new RemoteDatabase(this, dbName);
+    }
+
+    /**
+     * HTTP isteği gönderir (Hata durumunda otomatik tekrar denemeli).
+     * @private
+     */
+    async _request(method, path, body = null, retryCount = 0) {
+        try {
+            return await new Promise((resolve, reject) => {
+                const bodyStr = body ? JSON.stringify(body) : null;
+
+                const options = {
+                    hostname: this.host,
+                    port: this.port,
+                    path: path,
+                    method: method,
+                    headers: {
+                        'Content-Type': 'application/json',
+                        ...(this.secret ? { 'x-secret': this.secret } : {}),
+                        ...(bodyStr ? { 'Content-Length': Buffer.byteLength(bodyStr) } : {})
+                    }
+                };
+
+                const req = http.request(options, (res) => {
+                    let data = '';
+                    res.on('data', chunk => { data += chunk; });
+                    res.on('end', () => {
+                        try {
+                            const parsed = JSON.parse(data);
+                            resolve(parsed);
+                        } catch (e) {
+                            reject(new Error('Sunucudan geçersiz yanıt.'));
+                        }
+                    });
+                });
+
+                req.setTimeout(this.timeout, () => {
+                    req.destroy();
+                    reject(new Error(`Zaman aşımı (${this.timeout}ms)`));
+                });
+
+                req.on('error', (err) => {
+                    reject(err);
+                });
+
+                if (bodyStr) req.write(bodyStr);
+                req.end();
+            });
+        } catch (error) {
+            // Sadece bağlantı hatalarında ve zaman aşımında tekrar dene
+            if (retryCount < this.maxRetries) {
+                console.warn(`⚠️ [Monster-Retry] ${path} hatası: ${error.message}. Tekrar deneniyor (${retryCount + 1}/${this.maxRetries})...`);
+                await new Promise(r => setTimeout(r, this.retryDelay));
+                return this._request(method, path, body, retryCount + 1);
+            }
+            throw new Error(`[DevCode Remote] ${path} başarısız: ${error.message}`);
+        }
+    }
+}
+
+/**
+ * Uzak veritabanı örneği — RemoteClient.use() tarafından oluşturulur.
+ */
+class RemoteDatabase {
+    constructor(client, dbName) {
+        this._client = client;
+        this._dbName = dbName;
+    }
+
+    /**
+     * Bir koleksiyona bağlanır.
+     * @param {string} name
+     * @returns {RemoteCollection}
+     */
+    collection(name) {
+        return new RemoteCollection(this._client, this._dbName, name);
+    }
+
+    /**
+     * Koleksiyon listesini getirir (Dashboard için).
+     */
+    async listCollections() {
+        return this._client._request('GET', `/use/${this._dbName}/-dummy-/collections`)
+            .then(res => res.data);
+    }
+}
+
+/**
+ * Uzak koleksiyon — yerel Collection ile aynı API'ye sahiptir.
+ */
+class RemoteCollection {
+    constructor(client, dbName, collectionName) {
+        this._client = client;
+        this._base = `/use/${dbName}/${collectionName}`;
+    }
+
+    /** @private */
+    _post(action, body) {
+        return this._client._request('POST', `${this._base}/${action}`, body)
+            .then(res => res.data);
+    }
+
+    /** @private */
+    _get(action) {
+        return this._client._request('GET', `${this._base}/${action}`)
+            .then(res => res.data);
+    }
+
+    /**
+     * Tek bir belge ekler.
+     * @param {object} doc
+     */
+    async insert(doc) {
+        return this._post('insert', { doc });
+    }
+
+    /**
+     * Birden fazla belge ekler.
+     * @param {object[]} docs
+     */
+    async insertMany(docs) {
+        return this._post('insertMany', { docs });
+    }
+
+    /**
+     * Sorguya uyan tüm belgeleri getirir.
+     * @param {object} query
+     */
+    async find(query = {}) {
+        return this._post('find', { query });
+    }
+
+    /**
+     * Sorguya uyan ilk belgeyi getirir.
+     * @param {object} query
+     */
+    async findOne(query = {}) {
+        return this._post('findOne', { query });
+    }
+
+    /**
+     * Sorguya uyan ilk belgeyi günceller.
+     * @param {object} query
+     * @param {object} update
+     */
+    async update(query, update) {
+        return this._post('update', { query, update });
+    }
+
+    /**
+     * Sorguya uyan tüm belgeleri günceller.
+     * @param {object} query
+     * @param {object} update
+     */
+    async updateMany(query, update) {
+        return this._post('updateMany', { query, update });
+    }
+
+    /**
+     * Sorguya uyan ilk belgeyi siler.
+     * @param {object} query
+     */
+    async delete(query) {
+        return this._post('delete', { query });
+    }
+
+    /**
+     * Sorguya uyan tüm belgeleri siler.
+     * @param {object} query
+     */
+    async deleteMany(query) {
+        return this._post('deleteMany', { query });
+    }
+
+    /**
+     * Belge sayısını döner.
+     * @param {object} query
+     */
+    async count(query = {}) {
+        return this._post('count', { query });
+    }
+
+    /**
+     * Koleksiyonu tamamen siler.
+     */
+    async drop() {
+        return this._post('drop', {});
+    }
+
+    /** Dashboard uyumluluğu için alias */
+    async remove(query) {
+        return this.delete(query);
+    }
+}
+
+module.exports = RemoteClient;

package/lib/Schema.js

@@ -0,0 +1,54 @@
+/**
+ * DevCode Schema Validator
+ * Verilerin bütünlüğünü ve doğruluğunu kontrol eder.
+ */
+class Schema {
+    constructor(definition) {
+        this.definition = definition;
+    }
+
+    /**
+     * Dökümanı şemaya göre doğrular.
+     */
+    validate(doc) {
+        const errors = [];
+
+        for (let field in this.definition) {
+            const rules = this.definition[field];
+            const value = doc[field];
+
+            // Zorunlu alan kontrolü
+            if (rules.required && (value === undefined || value === null)) {
+                errors.push(`${field} alanı zorunludur.`);
+                continue;
+            }
+
+            if (value !== undefined) {
+                // Tip kontrolü
+                if (rules.type && typeof value !== rules.type && rules.type !== 'array') {
+                    errors.push(`${field} alanı ${rules.type} tipinde olmalıdır.`);
+                }
+
+                // Array kontrolü
+                if (rules.type === 'array' && !Array.isArray(value)) {
+                    errors.push(`${field} alanı bir dizi olmalıdır.`);
+                }
+
+                // Özel doğrulama (validator function)
+                if (rules.validate && typeof rules.validate === 'function') {
+                    if (!rules.validate(value)) {
+                        errors.push(`${field} alanı geçersiz değer içeriyor.`);
+                    }
+                }
+            }
+        }
+
+        if (errors.length > 0) {
+            throw new Error(`Şema Doğrulama Hatası: ${errors.join(' ')}`);
+        }
+
+        return true;
+    }
+}
+
+module.exports = Schema;

package/lib/Server.js

@@ -0,0 +1,224 @@
+const http = require('http');
+const url = require('url');
+
+/**
+ * DevCode Remote Server
+ * VDS üzerinde çalışır. HTTP API ile uzaktan veritabanı erişimi sağlar.
+ * Kullanıcılar RemoteClient ile bu sunucuya bağlanır.
+ */
+class Server {
+    /**
+     * @param {object} devcode  - DevCode core örneği
+     * @param {object} options
+     * @param {number} options.port    - Sunucu portu (varsayılan: 4242)
+     * @param {string} options.secret  - Güvenlik anahtarı (boş bırakılırsa açık erişim)
+     */
+    constructor(devcode, options = {}) {
+        this.devcode = devcode;
+        this.port = options.port || 4242;
+        this.secret = options.secret || null;
+        this.rateLimit = options.rateLimit || 100; // Dakikada 100 istek sınırı
+        this.requestTracker = new Map(); // IP/Secret bazlı istek takibi
+        this._server = null;
+    }
+
+    /**
+     * Sunucuyu başlatır.
+     */
+    start() {
+        this._server = http.createServer((req, res) => {
+            this._handle(req, res);
+        });
+
+        this._server.listen(this.port, '0.0.0.0', () => {
+            console.log(`\x1b[32m[DevCode Server]\x1b[0m Uzak veritabanı sunucusu aktif → Port: \x1b[33m${this.port}\x1b[0m`);
+            if (this.secret) {
+                console.log(`\x1b[32m[DevCode Server]\x1b[0m Güvenlik: \x1b[32mAktif\x1b[0m (secret key gerekli)`);
+            } else {
+                console.log(`\x1b[33m[DevCode Server]\x1b[0m Uyarı: Güvenlik anahtarı tanımlanmadı! Açık erişim aktif.`);
+            }
+        });
+
+        return this;
+    }
+
+    /**
+     * Sunucuyu durdurur.
+     */
+    stop() {
+        if (this._server) {
+            this._server.close();
+            console.log('\x1b[33m[DevCode Server]\x1b[0m Sunucu durduruldu.');
+        }
+    }
+
+    /**
+     * HTTP isteklerini işler.
+     * @private
+     */
+    async _handle(req, res) {
+        res.setHeader('Content-Type', 'application/json');
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, x-secret');
+
+        // simple rate limit logic
+        const ip = req.socket.remoteAddress;
+        const now = Date.now();
+        const clientData = this.requestTracker.get(ip) || { count: 0, startTime: now };
+
+        if (now - clientData.startTime > 60000) {
+            clientData.count = 0;
+            clientData.startTime = now;
+        }
+
+        clientData.count++;
+        this.requestTracker.set(ip, clientData);
+
+        if (clientData.count > this.rateLimit) {
+            res.writeHead(429);
+            return res.end(JSON.stringify({ ok: false, error: 'Rate limit aşıldı! Lütfen bekleyin.' }));
+        }
+
+        // OPTIONS (preflight) isteğini yanıtla
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            return res.end();
+        }
+
+        let namespace = 'public'; // Varsayılan namespace
+        // Kimlik doğrulama
+        if (this.secret) {
+            const clientSecret = req.headers['x-secret'];
+            if (clientSecret !== this.secret) {
+                res.writeHead(401);
+                return res.end(JSON.stringify({ ok: false, error: 'Geçersiz güvenlik anahtarı.' }));
+            }
+            namespace = clientSecret; // Güvenlik anahtarı aynı zamanda namespace olarak kullanılır
+        }
+
+        // URL parse: /use/:db/:collection/:action
+        const parsed = url.parse(req.url, true);
+        const parts = parsed.pathname.replace(/^\//, '').split('/');
+
+        // Özel route: GET /ping — bağlantı testi
+        if (parts[0] === 'ping') {
+            res.writeHead(200);
+            return res.end(JSON.stringify({ ok: true, message: 'pong', version: '2.0' }));
+        }
+
+        // Özel route: GET /databases — veritabanı listesi
+        if (parts[0] === 'databases') {
+            res.writeHead(200);
+            return res.end(JSON.stringify({ ok: true, data: this.devcode.listDatabases(namespace) }));
+        }
+
+        // Beklenen format: /use/:db/:collection/:action
+        if (parts[0] !== 'use' || parts.length < 4) {
+            res.writeHead(400);
+            return res.end(JSON.stringify({ ok: false, error: 'Geçersiz route. Format: /use/:db/:collection/:action' }));
+        }
+
+        const [, dbName, collectionName, action] = parts;
+
+        try {
+            const db = this.devcode.use(dbName, namespace);
+            const col = db.collection(collectionName);
+
+            // İstek gövdesini oku
+            let body = {};
+            if (req.method === 'POST') {
+                body = await this._readBody(req);
+            }
+
+            let result;
+
+            switch (action) {
+                case 'insert':
+                    result = await col.insert(body.doc);
+                    break;
+                case 'insertMany':
+                    result = await col.insertMany(body.docs);
+                    break;
+                case 'find':
+                    result = col.find(body.query || {});
+                    break;
+                case 'findOne':
+                    result = col.findOne(body.query || {});
+                    break;
+                case 'update':
+                    result = await col.update(body.query, body.update);
+                    break;
+                case 'updateMany':
+                    result = await col.updateMany(body.query, body.update);
+                    break;
+                case 'delete':
+                    result = await col.delete(body.query);
+                    break;
+                case 'deleteMany':
+                    result = await col.deleteMany(body.query);
+                    break;
+                case 'count':
+                    result = col.count(body.query || {});
+                    break;
+                case 'drop':
+                    result = col.drop();
+                    break;
+                case 'collections':
+                    result = db.listCollections();
+                    break;
+                default:
+                    res.writeHead(400);
+                    return res.end(JSON.stringify({ ok: false, error: `Bilinmeyen işlem: ${action}` }));
+            }
+
+            res.writeHead(200);
+            res.end(JSON.stringify({ ok: true, data: result }));
+        } catch (err) {
+            res.writeHead(500);
+            res.end(JSON.stringify({ ok: false, error: err.message }));
+        }
+    }
+
+    _readBody(req) {
+        return new Promise((resolve, reject) => {
+            let body = '';
+            req.on('data', chunk => { body += chunk.toString(); });
+            req.on('end', () => {
+                try {
+                    resolve(body ? JSON.parse(body) : {});
+                } catch (e) {
+                    reject(new Error('Geçersiz JSON gövdesi.'));
+                }
+            });
+            req.on('error', reject);
+        });
+    }
+
+    /**
+     * Sunucuyu başlatır ve dinler.
+     */
+    startServer(port) {
+        this.port = port || this.port;
+        this.start();
+        return this;
+    }
+
+    /**
+     * Görsel paneli başlatır.
+     */
+    startDashboard(port) {
+        this.devcode.startDashboard(port);
+        return this;
+    }
+
+    /**
+     * İnteraktif kabuğu başlatır.
+     */
+    startShell() {
+        this.devcode.startShell();
+        return this;
+    }
+}
+
+module.exports = Server;

package/lib/Storage.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const zlib = require('zlib');
+const path = require('path');
+
+/**
+ * DevCode Storage Engine 2.0 (Enterprise Edition)
+ * Veri güvenliğini atomik işlemlerle (Atomic Write) sağlar.
+ */
+class Storage {
+    /**
+     * Veriyi atomik olarak diske yazar.
+     * Bu yöntem veri bozulmasını (corruption) %100 önler.
+     */
+    static save(filePath, data, compress = false) {
+        const json = JSON.stringify(data);
+        const tempPath = `${filePath}.tmp`;
+
+        try {
+            if (compress) {
+                const buffer = zlib.gzipSync(json);
+                fs.writeFileSync(tempPath, buffer);
+            } else {
+                fs.writeFileSync(tempPath, json, 'utf8');
+            }
+
+            // ATOMİK YER DEĞİŞTİRME: Dosya tamamen yazılmadan asıl dosya değişmez.
+            fs.renameSync(tempPath, compress ? filePath + '.gz' : filePath);
+        } catch (err) {
+            if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+            throw new Error(`Kritik Depolama Hatası: ${err.message}`);
+        }
+    }
+
+    /**
+     * Veriyi diskten okur.
+     */
+    static load(filePath) {
+        const gzPath = filePath + '.gz';
+
+        if (fs.existsSync(gzPath)) {
+            const buffer = fs.readFileSync(gzPath);
+            const json = zlib.gunzipSync(buffer).toString();
+            return JSON.parse(json);
+        } else if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf8');
+            return JSON.parse(content || '[]');
+        }
+        return [];
+    }
+}
+
+module.exports = Storage;

package/lib/UpdateParser.js

@@ -0,0 +1,71 @@
+/**
+ * Advanced Update Parser (Enterprise Edition)
+ * MongoDB benzeri güncelleme operatörlerini ($set, $inc, $push, $pull, $unset) işler.
+ */
+class UpdateParser {
+    /**
+     * Bir dökümanı verilen güncelleme sorgusuna göre mutasyona uğratır.
+     * @param {Object} doc Güncellenecek döküman
+     * @param {Object} updateQuery Güncelleme sorgusu ($set, $inc vb.)
+     * @returns {Object} Güncellenmiş döküman
+     */
+    static parse(doc, updateQuery) {
+        for (let key in updateQuery) {
+            const val = updateQuery[key];
+
+            switch (key) {
+                case '$set':
+                    for (let field in val) doc[field] = val[field];
+                    break;
+
+                case '$inc':
+                    for (let field in val) {
+                        if (typeof doc[field] === 'number') doc[field] += val[field];
+                        else doc[field] = val[field];
+                    }
+                    break;
+
+                case '$push':
+                    for (let field in val) {
+                        if (!Array.isArray(doc[field])) doc[field] = [];
+                        doc[field].push(val[field]);
+                    }
+                    break;
+
+                case '$pull':
+                    for (let field in val) {
+                        if (Array.isArray(doc[field])) {
+                            doc[field] = doc[field].filter(v => v !== val[field]);
+                        }
+                    }
+                    break;
+
+                case '$unset':
+                    for (let field in val) {
+                        if (val[field]) delete doc[field];
+                    }
+                    break;
+
+                case '$rename':
+                    for (let field in val) {
+                        const newName = val[field];
+                        if (doc[field] !== undefined) {
+                            doc[newName] = doc[field];
+                            delete doc[field];
+                        }
+                    }
+                    break;
+
+                default:
+                    // Eğer operatör değilse, direkt set olarak kabul et (Mongo mantığı)
+                    if (!key.startsWith('$')) {
+                        doc[key] = val;
+                    }
+                    break;
+            }
+        }
+        return doc;
+    }
+}
+
+module.exports = UpdateParser;