atoo-studio 0.0.1 → 0.0.2

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

@@ -0,0 +1,91 @@
+import { Client } from 'cassandra-driver';
+export class CassandraDriver {
+    client = null;
+    keyspace = '';
+    async connect(params) {
+        const host = params.host || 'localhost';
+        const port = params.port || 9042;
+        this.keyspace = params.database || '';
+        const opts = {
+            contactPoints: [`${host}:${port}`],
+            localDataCenter: 'datacenter1',
+        };
+        if (this.keyspace) {
+            opts.keyspace = this.keyspace;
+        }
+        if (params.username && params.password) {
+            opts.credentials = { username: params.username, password: params.password };
+        }
+        this.client = new Client(opts);
+        await this.client.connect();
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.shutdown();
+            this.client = null;
+        }
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+    async query(cql, limit = 100) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const start = Date.now();
+        const result = await this.client.execute(cql);
+        const elapsed = Date.now() - start;
+        const columns = result.columns ? result.columns.map((c) => c.name) : [];
+        const rows = (result.rows || []).slice(0, limit).map((row) => {
+            const obj = {};
+            for (const col of columns) {
+                obj[col] = row[col];
+            }
+            return obj;
+        });
+        return {
+            columns,
+            rows,
+            row_count: rows.length,
+            execution_time_ms: elapsed,
+            truncated: (result.rows || []).length > limit,
+        };
+    }
+    async getTables() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const keyspace = this.keyspace || this.client.keyspace;
+        if (!keyspace)
+            throw new Error('No keyspace selected');
+        const result = await this.client.execute('SELECT table_name FROM system_schema.tables WHERE keyspace_name = ?', [keyspace]);
+        return (result.rows || []).map((row) => ({
+            name: row.table_name,
+            type: 'table',
+        }));
+    }
+    async describeTable(table) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const keyspace = this.keyspace || this.client.keyspace;
+        if (!keyspace)
+            throw new Error('No keyspace selected');
+        const result = await this.client.execute('SELECT column_name, type, kind FROM system_schema.columns WHERE keyspace_name = ? AND table_name = ?', [keyspace, table]);
+        const columns = (result.rows || []).map((row) => ({
+            name: row.column_name,
+            type: row.type,
+            nullable: row.kind !== 'partition_key' && row.kind !== 'clustering',
+            primary_key: row.kind === 'partition_key' || row.kind === 'clustering',
+        }));
+        return {
+            table,
+            columns,
+            indexes: [],
+            foreign_keys: [],
+        };
+    }
+    async getDatabases() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const result = await this.client.execute('SELECT keyspace_name FROM system_schema.keyspaces');
+        return (result.rows || []).map((row) => row.keyspace_name);
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { ConnectionParams, DatabaseDriver, QueryResult, TableInfo, SchemaInfo } from '../types.js';
+export declare class ClickHouseDriver implements DatabaseDriver {
+    private client;
+    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/clickhouse.js

@@ -0,0 +1,127 @@
+import { createClient } from '@clickhouse/client';
+export class ClickHouseDriver {
+    client = null;
+    async connect(params) {
+        if (params.connection_string) {
+            this.client = createClient({ url: params.connection_string });
+        }
+        else {
+            const host = params.host || 'localhost';
+            const port = params.port || 8123;
+            this.client = createClient({
+                url: `http://${host}:${port}`,
+                username: params.username || 'default',
+                password: params.password || '',
+                database: params.database || 'default',
+            });
+        }
+        // Test connection
+        await this.client.query({ query: 'SELECT 1', format: 'JSONEachRow' });
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+        }
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+    async query(sql, limit = 100) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const start = Date.now();
+        const result = await this.client.query({ query: sql, format: 'JSONEachRow' });
+        const rows = await result.json();
+        const elapsed = Date.now() - start;
+        const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
+        const truncated = rows.length > limit;
+        return {
+            columns,
+            rows: rows.slice(0, limit),
+            row_count: rows.length,
+            execution_time_ms: elapsed,
+            truncated,
+        };
+    }
+    async getTables() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const result = await this.client.query({
+            query: `
+        SELECT
+          name,
+          engine AS type,
+          total_rows,
+          total_bytes
+        FROM system.tables
+        WHERE database = currentDatabase()
+        ORDER BY name
+      `,
+            format: 'JSONEachRow',
+        });
+        const rows = await result.json();
+        return rows.map(r => ({
+            name: r.name,
+            type: inferTableType(r.type),
+            row_count: r.total_rows != null ? Number(r.total_rows) : undefined,
+            size_bytes: r.total_bytes != null ? Number(r.total_bytes) : undefined,
+        }));
+    }
+    async describeTable(table) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const result = await this.client.query({
+            query: `DESCRIBE TABLE ${quoteIdentifier(table)}`,
+            format: 'JSONEachRow',
+        });
+        const rows = await result.json();
+        const columns = rows.map(r => ({
+            name: r.name,
+            type: r.type,
+            nullable: /Nullable/.test(r.type),
+            default_value: r.default_expression || undefined,
+            comment: r.comment || undefined,
+        }));
+        // Fetch primary key columns
+        const pkResult = await this.client.query({
+            query: `
+        SELECT name, sorting_key
+        FROM system.tables
+        WHERE database = currentDatabase() AND name = {tableName:String}
+      `,
+            format: 'JSONEachRow',
+            query_params: { tableName: table },
+        });
+        const pkRows = await pkResult.json();
+        if (pkRows.length > 0 && pkRows[0].sorting_key) {
+            const pkCols = new Set(pkRows[0].sorting_key.split(',').map(s => s.trim()));
+            for (const col of columns) {
+                if (pkCols.has(col.name)) {
+                    col.primary_key = true;
+                }
+            }
+        }
+        return { table, columns };
+    }
+    async getDatabases() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const result = await this.client.query({
+            query: 'SHOW DATABASES',
+            format: 'JSONEachRow',
+        });
+        const rows = await result.json();
+        return rows.map(r => r.name);
+    }
+}
+function quoteIdentifier(id) {
+    return `\`${id.replace(/`/g, '``')}\``;
+}
+function inferTableType(engine) {
+    if (/MaterializedView/i.test(engine))
+        return 'materialized_view';
+    if (/View/i.test(engine))
+        return 'view';
+    return 'table';
+}

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

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

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

@@ -0,0 +1,169 @@
+import { Client } from '@elastic/elasticsearch';
+export class ElasticsearchDriver {
+    client = null;
+    connected = false;
+    async connect(params) {
+        const port = params.port || 9200;
+        const node = params.connection_string || `http://${params.host || 'localhost'}:${port}`;
+        const opts = { node };
+        if (params.username && params.password) {
+            opts.auth = { username: params.username, password: params.password };
+        }
+        this.client = new Client(opts);
+        // Verify connectivity
+        const ok = await this.client.ping();
+        if (!ok) {
+            this.client = null;
+            throw new Error('Elasticsearch ping failed');
+        }
+        this.connected = true;
+    }
+    async disconnect() {
+        if (this.client) {
+            await this.client.close();
+            this.client = null;
+            this.connected = false;
+        }
+    }
+    isConnected() {
+        return this.client !== null && this.connected;
+    }
+    async query(queryStr, limit = 100) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const start = Date.now();
+        const trimmed = queryStr.trim();
+        let searchParams;
+        if (trimmed.startsWith('{')) {
+            // JSON query DSL: {"index": "my-index", "query": {"match_all": {}}}
+            searchParams = JSON.parse(trimmed);
+            if (!searchParams.size && limit) {
+                searchParams.size = limit;
+            }
+        }
+        else {
+            // Simple format: index_name or index_name {"match": {"field": "value"}}
+            const firstSpace = trimmed.indexOf(' ');
+            let index;
+            let queryBody = { match_all: {} };
+            if (firstSpace === -1) {
+                index = trimmed;
+            }
+            else {
+                index = trimmed.substring(0, firstSpace);
+                const rest = trimmed.substring(firstSpace + 1).trim();
+                if (rest) {
+                    queryBody = JSON.parse(rest);
+                }
+            }
+            searchParams = {
+                index,
+                query: queryBody,
+                size: limit,
+            };
+        }
+        const response = await this.client.search(searchParams);
+        const elapsed = Date.now() - start;
+        const hits = (response.hits?.hits || []);
+        const rows = hits.map(hit => {
+            const source = (hit._source || {});
+            return {
+                _id: hit._id,
+                _index: hit._index,
+                ...source,
+            };
+        });
+        const columns = rows.length > 0
+            ? [...new Set(rows.flatMap(r => Object.keys(r)))]
+            : [];
+        const totalHits = typeof response.hits?.total === 'number'
+            ? response.hits.total
+            : response.hits?.total?.value ?? rows.length;
+        return {
+            columns,
+            rows,
+            row_count: rows.length,
+            execution_time_ms: elapsed,
+            truncated: totalHits > rows.length,
+        };
+    }
+    async getTables() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const indices = await this.client.cat.indices({ format: 'json' });
+        const tables = indices.map(idx => ({
+            name: idx.index,
+            type: 'index',
+            row_count: idx['docs.count'] != null ? parseInt(idx['docs.count'], 10) : undefined,
+            size_bytes: idx['store.size'] ? parseStorageSize(idx['store.size']) : undefined,
+        }));
+        return tables.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async describeTable(index) {
+        if (!this.client)
+            throw new Error('Not connected');
+        const mappingResponse = await this.client.indices.getMapping({ index });
+        const indexMapping = mappingResponse[index];
+        const properties = indexMapping?.mappings?.properties || {};
+        const columns = flattenMappingProperties(properties);
+        return {
+            table: index,
+            columns,
+            indexes: [],
+            foreign_keys: [],
+        };
+    }
+    async getDatabases() {
+        if (!this.client)
+            throw new Error('Not connected');
+        const indices = await this.client.cat.indices({ format: 'json' });
+        return indices
+            .map(idx => idx.index)
+            .filter(Boolean)
+            .sort();
+    }
+}
+/**
+ * Flatten nested Elasticsearch mapping properties into a flat list of ColumnInfo.
+ * Nested objects are represented with dot notation (e.g. "address.city").
+ */
+function flattenMappingProperties(properties, prefix = '') {
+    const columns = [];
+    for (const [field, mapping] of Object.entries(properties)) {
+        const fullName = prefix ? `${prefix}.${field}` : field;
+        if (mapping.properties) {
+            // Nested object — recurse
+            columns.push(...flattenMappingProperties(mapping.properties, fullName));
+        }
+        else {
+            columns.push({
+                name: fullName,
+                type: mapping.type || 'object',
+                nullable: true, // ES fields are always optional
+            });
+        }
+    }
+    return columns;
+}
+/**
+ * Parse Elasticsearch human-readable storage sizes (e.g. "1.2mb", "500kb") to bytes.
+ */
+function parseStorageSize(size) {
+    if (typeof size === 'number')
+        return size;
+    if (!size)
+        return undefined;
+    const match = size.match(/^([\d.]+)\s*(b|kb|mb|gb|tb)$/i);
+    if (!match)
+        return undefined;
+    const value = parseFloat(match[1]);
+    const unit = match[2].toLowerCase();
+    const multipliers = {
+        b: 1,
+        kb: 1024,
+        mb: 1024 ** 2,
+        gb: 1024 ** 3,
+        tb: 1024 ** 4,
+    };
+    return Math.round(value * (multipliers[unit] || 1));
+}

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

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

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

@@ -0,0 +1,194 @@
+import { InfluxDB } from '@influxdata/influxdb-client';
+export class InfluxDBDriver {
+    client = null;
+    queryApi = null;
+    org = '';
+    bucket = '';
+    async connect(params) {
+        let url;
+        let token;
+        if (params.connection_string) {
+            // Parse connection string: http://host:port?org=myorg&bucket=mybucket or similar
+            const parsed = new URL(params.connection_string);
+            url = `${parsed.protocol}//${parsed.host}`;
+            token = params.password || parsed.searchParams.get('token') || '';
+            this.org = parsed.searchParams.get('org') || params.database || '';
+            this.bucket = parsed.searchParams.get('bucket') || '';
+        }
+        else {
+            const port = params.port || 8086;
+            const host = params.host || 'localhost';
+            url = `http://${host}:${port}`;
+            token = params.password || '';
+        }
+        // Handle org/bucket format in the database field
+        if (params.database && !this.org) {
+            if (params.database.includes('/')) {
+                const parts = params.database.split('/');
+                this.org = parts[0];
+                this.bucket = parts[1];
+            }
+            else {
+                this.org = params.database;
+                this.bucket = params.database;
+            }
+        }
+        if (!this.bucket && this.org) {
+            this.bucket = this.org;
+        }
+        this.client = new InfluxDB({ url, token });
+        this.queryApi = this.client.getQueryApi(this.org);
+        // Verify connectivity by running a simple query
+        try {
+            await this.queryApi.collectRows('buckets() |> limit(n: 1)');
+        }
+        catch (err) {
+            this.client = null;
+            this.queryApi = null;
+            throw new Error(`InfluxDB connection failed: ${err.message}`);
+        }
+    }
+    async disconnect() {
+        this.client = null;
+        this.queryApi = null;
+        this.org = '';
+        this.bucket = '';
+    }
+    isConnected() {
+        return this.client !== null;
+    }
+    async query(flux, limit) {
+        if (!this.queryApi)
+            throw new Error('Not connected');
+        const start = Date.now();
+        let effectiveQuery = flux.trim();
+        if (limit && !effectiveQuery.includes('|> limit(')) {
+            effectiveQuery += ` |> limit(n: ${limit})`;
+        }
+        const rawRows = await this.queryApi.collectRows(effectiveQuery);
+        const elapsed = Date.now() - start;
+        // Convert InfluxDB row objects — strip internal metadata prefixes
+        const rows = rawRows.map(row => {
+            const record = {};
+            for (const [key, value] of Object.entries(row)) {
+                record[key] = value;
+            }
+            return record;
+        });
+        const columns = rows.length > 0
+            ? [...new Set(rows.flatMap(r => Object.keys(r)))]
+            : [];
+        return {
+            columns,
+            rows,
+            row_count: rows.length,
+            execution_time_ms: elapsed,
+        };
+    }
+    async getTables() {
+        if (!this.queryApi)
+            throw new Error('Not connected');
+        const tables = [];
+        // If we have a specific bucket, list measurements within it
+        if (this.bucket) {
+            try {
+                const flux = `import "influxdata/influxdb/schema"\nschema.measurements(bucket: "${escapeBucket(this.bucket)}")`;
+                const rows = await this.queryApi.collectRows(flux);
+                for (const row of rows) {
+                    const name = row._value || row.name;
+                    if (name) {
+                        tables.push({ name: String(name), type: 'measurement' });
+                    }
+                }
+            }
+            catch {
+                // Fall back to listing buckets if measurement listing fails
+            }
+        }
+        // If no measurements found, or no bucket specified, list buckets
+        if (tables.length === 0) {
+            const flux = 'buckets()';
+            const rows = await this.queryApi.collectRows(flux);
+            for (const row of rows) {
+                const name = row.name;
+                if (name && !String(name).startsWith('_')) {
+                    tables.push({ name: String(name), type: 'bucket' });
+                }
+            }
+        }
+        return tables.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    async describeTable(measurement) {
+        if (!this.queryApi)
+            throw new Error('Not connected');
+        const bucket = escapeBucket(this.bucket);
+        const meas = escapeMeasurement(measurement);
+        const columns = [];
+        // Get field keys
+        try {
+            const fieldFlux = `import "influxdata/influxdb/schema"\nschema.measurementFieldKeys(bucket: "${bucket}", measurement: "${meas}")`;
+            const fieldRows = await this.queryApi.collectRows(fieldFlux);
+            for (const row of fieldRows) {
+                const name = row._value || row.name;
+                if (name) {
+                    columns.push({
+                        name: String(name),
+                        type: 'field',
+                        nullable: true,
+                    });
+                }
+            }
+        }
+        catch {
+            // Field key listing not supported on all versions
+        }
+        // Get tag keys
+        try {
+            const tagFlux = `import "influxdata/influxdb/schema"\nschema.measurementTagKeys(bucket: "${bucket}", measurement: "${meas}")`;
+            const tagRows = await this.queryApi.collectRows(tagFlux);
+            for (const row of tagRows) {
+                const name = row._value || row.name;
+                if (name && !String(name).startsWith('_')) {
+                    columns.push({
+                        name: String(name),
+                        type: 'tag',
+                        nullable: true,
+                    });
+                }
+            }
+        }
+        catch {
+            // Tag key listing not supported on all versions
+        }
+        // Always include the implicit _time column
+        if (!columns.some(c => c.name === '_time')) {
+            columns.unshift({
+                name: '_time',
+                type: 'timestamp',
+                nullable: false,
+            });
+        }
+        return {
+            table: measurement,
+            columns,
+            indexes: [],
+            foreign_keys: [],
+        };
+    }
+    async getDatabases() {
+        if (!this.queryApi)
+            throw new Error('Not connected');
+        const flux = 'buckets() |> keep(columns: ["name"])';
+        const rows = await this.queryApi.collectRows(flux);
+        return rows
+            .map(row => String(row.name || ''))
+            .filter(name => name && !name.startsWith('_'))
+            .sort();
+    }
+}
+function escapeBucket(bucket) {
+    return bucket.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+function escapeMeasurement(measurement) {
+    return measurement.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}

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

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