atoo-studio 0.0.1 → 0.0.2

package/dist/src/database/drivers/memcached.js

@@ -0,0 +1,117 @@
+import memjs from 'memjs';
+export class MemcachedDriver {
+    client = null;
+    async connect(params) {
+        const host = params.host || 'localhost';
+        const port = params.port || 11211;
+        this.client = memjs.Client.create(`${host}:${port}`);
+    }
+    async disconnect() {
+        if (this.client) {
+            this.client.close();
+            this.client = null;
+        }
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+    async query(command, limit = 100) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const start = Date.now();
+        const parts = command.trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        let columns = [];
+        let rows = [];
+        switch (cmd) {
+            case 'get': {
+                if (!parts[1])
+                    throw new Error('Usage: get <key>');
+                const key = parts[1];
+                const result = await this.client.get(key);
+                columns = ['key', 'value'];
+                const value = result.value ? result.value.toString() : '(nil)';
+                rows = [{ key, value }];
+                break;
+            }
+            case 'set': {
+                if (!parts[1] || !parts[2])
+                    throw new Error('Usage: set <key> <value>');
+                const key = parts[1];
+                const value = parts.slice(2).join(' ');
+                await this.client.set(key, value);
+                columns = ['result'];
+                rows = [{ result: 'STORED' }];
+                break;
+            }
+            case 'delete': {
+                if (!parts[1])
+                    throw new Error('Usage: delete <key>');
+                const key = parts[1];
+                const success = await this.client.delete(key);
+                columns = ['result'];
+                rows = [{ result: success ? 'DELETED' : 'NOT_FOUND' }];
+                break;
+            }
+            case 'stats': {
+                const stats = await new Promise((resolve, reject) => {
+                    this.client.stats((err, _server, stats) => {
+                        if (err)
+                            return reject(err);
+                        resolve(stats || {});
+                    });
+                }).catch(() => ({}));
+                columns = ['stat', 'value'];
+                for (const [stat, value] of Object.entries(stats)) {
+                    rows.push({ stat, value: String(value) });
+                }
+                rows = rows.slice(0, limit);
+                break;
+            }
+            case 'flush_all': {
+                await new Promise((resolve) => {
+                    this.client.flush(() => resolve());
+                });
+                columns = ['result'];
+                rows = [{ result: 'OK' }];
+                break;
+            }
+            default:
+                throw new Error(`Unsupported command: ${cmd}. Supported: get, set, delete, stats, flush_all`);
+        }
+        return {
+            columns,
+            rows,
+            row_count: rows.length,
+            execution_time_ms: Date.now() - start,
+        };
+    }
+    async getTables() {
+        if (!this.client)
+            throw new Error('Not connected');
+        try {
+            const stats = await new Promise((resolve, reject) => {
+                this.client.stats((err, _server, s) => {
+                    if (err)
+                        return reject(err);
+                    resolve(s || {});
+                });
+            });
+            return [{ name: 'memcached', type: 'server', row_count: Object.keys(stats).length }];
+        }
+        catch {
+            return [{ name: 'memcached', type: 'server' }];
+        }
+    }
+    async describeTable(_table) {
+        return {
+            table: _table,
+            columns: [],
+            indexes: [],
+            foreign_keys: [],
+        };
+    }
+    async getDatabases() {
+        return [];
+    }
+}

package/dist/src/database/drivers/mongodb.d.ts

@@ -0,0 +1,12 @@
+import type { ConnectionParams, DatabaseDriver, QueryResult, TableInfo, SchemaInfo } from '../types.js';
+export declare class MongoDBDriver implements DatabaseDriver {
+    private client;
+    private db;
+    connect(params: ConnectionParams): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query(queryStr: string, limit?: number): Promise<QueryResult>;
+    getTables(): Promise<TableInfo[]>;
+    describeTable(collection: string): Promise<SchemaInfo>;
+    getDatabases(): Promise<string[]>;
+}

package/dist/src/database/drivers/mongodb.js

@@ -0,0 +1,128 @@
+import { MongoClient } from 'mongodb';
+export class MongoDBDriver {
+    client = null;
+    db = null;
+    async connect(params) {
+        const uri = params.connection_string ||
+            `mongodb://${params.username ? `${params.username}:${params.password}@` : ''}${params.host || 'localhost'}:${params.port || 27017}/${params.database || 'test'}`;
+        this.client = new MongoClient(uri);
+        await this.client.connect();
+        this.db = this.client.db(params.database || 'test');
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+            this.db = null;
+        }
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+    async query(queryStr, limit = 100) {
+        if (!this.db)
+            throw new Error('Not connected');
+        const start = Date.now();
+        // Parse simple query format: collection.find({...}) or collection.aggregate([...])
+        const match = queryStr.match(/^(\w+)\.(find|aggregate|count|countDocuments|distinct)\((.*)?\)$/s);
+        if (!match) {
+            throw new Error('Query format: collection.find({filter}) or collection.aggregate([pipeline])');
+        }
+        const [, collName, method, argsStr] = match;
+        const collection = this.db.collection(collName);
+        let args;
+        try {
+            args = argsStr ? JSON.parse(argsStr) : {};
+        }
+        catch {
+            args = {};
+        }
+        let rows;
+        if (method === 'find') {
+            rows = await collection.find(args).limit(limit).toArray();
+        }
+        else if (method === 'aggregate') {
+            rows = await collection.aggregate(Array.isArray(args) ? args : [args]).toArray();
+        }
+        else if (method === 'countDocuments' || method === 'count') {
+            const count = await collection.countDocuments(args);
+            rows = [{ count }];
+        }
+        else if (method === 'distinct') {
+            const values = await collection.distinct(typeof args === 'string' ? args : Object.keys(args)[0] || '_id');
+            rows = values.map(v => ({ value: v }));
+        }
+        else {
+            throw new Error(`Unsupported method: ${method}`);
+        }
+        const elapsed = Date.now() - start;
+        // Serialize ObjectIds
+        const serialized = rows.map(r => {
+            const obj = {};
+            for (const [k, v] of Object.entries(r)) {
+                obj[k] = v && typeof v === 'object' && v.toString ? v.toString() : v;
+            }
+            return obj;
+        });
+        const columns = serialized.length > 0
+            ? [...new Set(serialized.flatMap(r => Object.keys(r)))]
+            : [];
+        return {
+            columns,
+            rows: serialized.slice(0, limit),
+            row_count: serialized.length,
+            execution_time_ms: elapsed,
+            truncated: rows.length >= limit,
+        };
+    }
+    async getTables() {
+        if (!this.db)
+            throw new Error('Not connected');
+        const collections = await this.db.listCollections().toArray();
+        const tables = [];
+        for (const coll of collections) {
+            let row_count;
+            try {
+                row_count = await this.db.collection(coll.name).estimatedDocumentCount();
+            }
+            catch { }
+            tables.push({ name: coll.name, type: 'collection', row_count });
+        }
+        return tables.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async describeTable(collection) {
+        if (!this.db)
+            throw new Error('Not connected');
+        // Sample documents to infer schema
+        const sample = await this.db.collection(collection).find().limit(50).toArray();
+        const fieldTypes = new Map();
+        for (const doc of sample) {
+            for (const [key, value] of Object.entries(doc)) {
+                if (!fieldTypes.has(key))
+                    fieldTypes.set(key, new Set());
+                const t = value === null ? 'null' : Array.isArray(value) ? 'array' : typeof value;
+                fieldTypes.get(key).add(t);
+            }
+        }
+        const columns = [...fieldTypes.entries()].map(([name, types]) => ({
+            name,
+            type: [...types].join(' | '),
+            nullable: types.has('null') || types.has('undefined'),
+            primary_key: name === '_id',
+        }));
+        // Get indexes
+        const indexList = await this.db.collection(collection).indexes();
+        const indexes = indexList.map(idx => ({
+            name: idx.name || '',
+            columns: Object.keys(idx.key || {}),
+            unique: !!idx.unique,
+        }));
+        return { table: collection, columns, indexes, foreign_keys: [] };
+    }
+    async getDatabases() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const result = await this.client.db('admin').admin().listDatabases();
+        return result.databases.map(d => d.name);
+    }
+}

package/dist/src/database/drivers/mysql.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectionParams, DatabaseDriver, QueryResult, TableInfo, SchemaInfo } from '../types.js';
+export declare class MySQLDriver implements DatabaseDriver {
+    private pool;
+    connect(params: ConnectionParams): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query(sql: string, limit?: number): Promise<QueryResult>;
+    getTables(): Promise<TableInfo[]>;
+    describeTable(table: string): Promise<SchemaInfo>;
+    getDatabases(): Promise<string[]>;
+}

package/dist/src/database/drivers/mysql.js

@@ -0,0 +1,112 @@
+import mysql from 'mysql2/promise';
+export class MySQLDriver {
+    pool = null;
+    async connect(params) {
+        if (params.connection_string) {
+            this.pool = mysql.createPool(params.connection_string);
+        }
+        else {
+            this.pool = mysql.createPool({
+                host: params.host || 'localhost',
+                port: params.port || 3306,
+                user: params.username || 'root',
+                password: params.password || '',
+                database: params.database,
+                connectionLimit: 5,
+            });
+        }
+        // Test connection
+        const conn = await this.pool.getConnection();
+        conn.release();
+    }
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    isConnected() {
+        return this.pool !== null;
+    }
+    async query(sql, limit = 100) {
+        if (!this.pool)
+            throw new Error('Not connected');
+        const start = Date.now();
+        const [rows, fields] = await this.pool.query(sql);
+        const elapsed = Date.now() - start;
+        const rowArr = Array.isArray(rows) ? rows : [];
+        const columns = fields && Array.isArray(fields)
+            ? fields.map((f) => f.name)
+            : (rowArr.length > 0 ? Object.keys(rowArr[0]) : []);
+        const truncated = rowArr.length > limit;
+        return {
+            columns,
+            rows: rowArr.slice(0, limit),
+            row_count: rows.affectedRows ?? rowArr.length,
+            execution_time_ms: elapsed,
+            truncated,
+        };
+    }
+    async getTables() {
+        if (!this.pool)
+            throw new Error('Not connected');
+        const [rows] = await this.pool.query(`
+      SELECT TABLE_NAME AS name, TABLE_TYPE AS type, TABLE_ROWS AS row_count, DATA_LENGTH AS size_bytes
+      FROM information_schema.tables
+      WHERE TABLE_SCHEMA = DATABASE()
+      ORDER BY TABLE_NAME
+    `);
+        return rows.map(r => ({
+            name: r.name,
+            type: r.type === 'BASE TABLE' ? 'table' : r.type?.toLowerCase(),
+            row_count: r.row_count != null ? parseInt(r.row_count) : undefined,
+            size_bytes: r.size_bytes != null ? parseInt(r.size_bytes) : undefined,
+        }));
+    }
+    async describeTable(table) {
+        if (!this.pool)
+            throw new Error('Not connected');
+        const [cols] = await this.pool.query(`
+      SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT, COLUMN_KEY
+      FROM information_schema.columns
+      WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ?
+      ORDER BY ORDINAL_POSITION
+    `, [table]);
+        const columns = cols.map(c => ({
+            name: c.COLUMN_NAME,
+            type: c.DATA_TYPE,
+            nullable: c.IS_NULLABLE === 'YES',
+            default_value: c.COLUMN_DEFAULT || undefined,
+            primary_key: c.COLUMN_KEY === 'PRI',
+        }));
+        const [idxRows] = await this.pool.query(`SHOW INDEX FROM \`${table}\``);
+        const idxMap = new Map();
+        for (const r of idxRows) {
+            if (!idxMap.has(r.Key_name))
+                idxMap.set(r.Key_name, { columns: [], unique: !r.Non_unique });
+            idxMap.get(r.Key_name).columns.push(r.Column_name);
+        }
+        const indexes = [...idxMap.entries()].map(([name, v]) => ({ name, ...v }));
+        const [fkRows] = await this.pool.query(`
+      SELECT COLUMN_NAME, REFERENCED_TABLE_NAME, REFERENCED_COLUMN_NAME
+      FROM information_schema.KEY_COLUMN_USAGE
+      WHERE TABLE_SCHEMA = DATABASE() AND TABLE_NAME = ? AND REFERENCED_TABLE_NAME IS NOT NULL
+    `, [table]);
+        return {
+            table,
+            columns,
+            indexes,
+            foreign_keys: fkRows.map(r => ({
+                column: r.COLUMN_NAME,
+                ref_table: r.REFERENCED_TABLE_NAME,
+                ref_column: r.REFERENCED_COLUMN_NAME,
+            })),
+        };
+    }
+    async getDatabases() {
+        if (!this.pool)
+            throw new Error('Not connected');
+        const [rows] = await this.pool.query('SHOW DATABASES');
+        return rows.map(r => r.Database);
+    }
+}

package/dist/src/database/drivers/neo4j.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectionParams, DatabaseDriver, QueryResult, TableInfo, SchemaInfo } from '../types.js';
+export declare class Neo4jDriver implements DatabaseDriver {
+    private driver;
+    connect(params: ConnectionParams): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query(cypher: string, limit?: number): Promise<QueryResult>;
+    getTables(): Promise<TableInfo[]>;
+    describeTable(label: string): Promise<SchemaInfo>;
+    getDatabases(): Promise<string[]>;
+}

package/dist/src/database/drivers/neo4j.js

@@ -0,0 +1,158 @@
+import neo4j from 'neo4j-driver';
+function serializeValue(val) {
+    if (val === null || val === undefined)
+        return val;
+    if (neo4j.isInt(val))
+        return val.toNumber();
+    if (val instanceof neo4j.types.Node) {
+        return { labels: val.labels, properties: serializeRecord(val.properties) };
+    }
+    if (val instanceof neo4j.types.Relationship) {
+        return { type: val.type, properties: serializeRecord(val.properties) };
+    }
+    if (val instanceof neo4j.types.Path) {
+        const segments = val.segments.map((s) => `(${s.start.labels.join(':')})-[:${s.relationship.type}]->(${s.end.labels.join(':')})`);
+        return segments.join('');
+    }
+    if (Array.isArray(val))
+        return val.map(serializeValue);
+    if (typeof val === 'object')
+        return serializeRecord(val);
+    return val;
+}
+function serializeRecord(obj) {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        out[k] = serializeValue(v);
+    }
+    return out;
+}
+function inferType(val) {
+    if (val === null || val === undefined)
+        return 'unknown';
+    if (neo4j.isInt(val))
+        return 'integer';
+    if (typeof val === 'number')
+        return 'float';
+    if (typeof val === 'boolean')
+        return 'boolean';
+    if (typeof val === 'string')
+        return 'string';
+    if (Array.isArray(val))
+        return 'list';
+    if (val instanceof Date)
+        return 'datetime';
+    if (typeof val === 'object')
+        return 'map';
+    return typeof val;
+}
+export class Neo4jDriver {
+    driver = null;
+    async connect(params) {
+        const host = params.host || 'localhost';
+        const port = params.port || 7687;
+        const uri = params.connection_string || `bolt://${host}:${port}`;
+        const auth = params.username
+            ? neo4j.auth.basic(params.username, params.password || '')
+            : undefined;
+        this.driver = neo4j.driver(uri, auth);
+        await this.driver.verifyConnectivity();
+    }
+    async disconnect() {
+        if (this.driver) {
+            await this.driver.close();
+            this.driver = null;
+        }
+    }
+    isConnected() {
+        return this.driver !== null;
+    }
+    async query(cypher, limit) {
+        if (!this.driver)
+            throw new Error('Not connected');
+        const session = this.driver.session();
+        const start = Date.now();
+        try {
+            const result = await session.run(cypher);
+            const elapsed = Date.now() - start;
+            const rows = result.records.map((record) => {
+                const obj = {};
+                for (const key of record.keys) {
+                    obj[key] = serializeValue(record.get(key));
+                }
+                return obj;
+            });
+            const columns = result.records.length > 0
+                ? result.records[0].keys
+                : [];
+            const truncated = limit !== undefined && rows.length >= limit;
+            const sliced = limit !== undefined ? rows.slice(0, limit) : rows;
+            return {
+                columns,
+                rows: sliced,
+                row_count: sliced.length,
+                execution_time_ms: elapsed,
+                truncated,
+            };
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getTables() {
+        if (!this.driver)
+            throw new Error('Not connected');
+        const session = this.driver.session();
+        try {
+            const tables = [];
+            const labelsResult = await session.run('CALL db.labels()');
+            for (const record of labelsResult.records) {
+                tables.push({ name: record.get('label'), type: 'label' });
+            }
+            const relsResult = await session.run('CALL db.relationshipTypes()');
+            for (const record of relsResult.records) {
+                tables.push({ name: record.get('relationshipType'), type: 'relationship' });
+            }
+            return tables.sort((a, b) => a.name.localeCompare(b.name));
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async describeTable(label) {
+        if (!this.driver)
+            throw new Error('Not connected');
+        const session = this.driver.session();
+        try {
+            const result = await session.run(`MATCH (n:\`${label}\`) WITH n LIMIT 50 UNWIND keys(n) AS key RETURN DISTINCT key, head(collect(n[key])) AS sample`);
+            const columns = result.records.map((record) => {
+                const name = record.get('key');
+                const sample = record.get('sample');
+                return {
+                    name,
+                    type: inferType(sample),
+                    nullable: true,
+                };
+            });
+            return { table: label, columns, indexes: [], foreign_keys: [] };
+        }
+        finally {
+            await session.close();
+        }
+    }
+    async getDatabases() {
+        if (!this.driver)
+            throw new Error('Not connected');
+        const session = this.driver.session();
+        try {
+            const result = await session.run('SHOW DATABASES');
+            return result.records.map((record) => record.get('name'));
+        }
+        catch {
+            return ['neo4j'];
+        }
+        finally {
+            await session.close();
+        }
+    }
+}

package/dist/src/database/drivers/postgresql.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectionParams, DatabaseDriver, QueryResult, TableInfo, SchemaInfo } from '../types.js';
+export declare class PostgreSQLDriver implements DatabaseDriver {
+    private pool;
+    connect(params: ConnectionParams): Promise<void>;
+    disconnect(): Promise<void>;
+    isConnected(): boolean;
+    query(sql: string, limit?: number): Promise<QueryResult>;
+    getTables(): Promise<TableInfo[]>;
+    describeTable(table: string): Promise<SchemaInfo>;
+    getDatabases(): Promise<string[]>;
+}