crushdataai 1.2.14 → 1.2.15

package/dist/connectors/cloud/index.d.ts

@@ -8,11 +8,13 @@ export declare class BigQueryConnector implements Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
 }
 export declare class SnowflakeConnector implements Connector {
     type: string;
     private createConnection;
-    private executeQuery;
+    private executeInternal;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
     test(connection: Connection): Promise<boolean>;
     getTables(connection: Connection): Promise<Table[]>;
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;

package/dist/connectors/cloud/index.js

@@ -168,6 +168,18 @@ print(df.head())
         }
         return `# Language ${lang} not supported for BigQuery connector yet.`;
     }
+    async executeQuery(connection, query) {
+        console.log(`[BigQuery] executeQuery called for ${connection.name}`);
+        const bigquery = this.createClient(connection);
+        try {
+            const [rows] = await bigquery.query(query);
+            return rows;
+        }
+        catch (error) {
+            console.error(`[BigQuery] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+    }
 }
 exports.BigQueryConnector = BigQueryConnector;
 class SnowflakeConnector {
@@ -193,7 +205,7 @@ class SnowflakeConnector {
             });
         });
     }
-    executeQuery(conn, query) {
+    executeInternal(conn, query) {
         return new Promise((resolve, reject) => {
             conn.execute({
                 sqlText: query,
@@ -208,6 +220,22 @@ class SnowflakeConnector {
             });
         });
     }
+    async executeQuery(connection, query) {
+        console.log(`[Snowflake] executeQuery called for ${connection.name}`);
+        let conn = null;
+        try {
+            conn = await this.createConnection(connection);
+            return await this.executeInternal(conn, query);
+        }
+        catch (error) {
+            console.error(`[Snowflake] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+        finally {
+            if (conn)
+                conn.destroy(() => { });
+        }
+    }
     async test(connection) {
         console.log(`[Snowflake] Testing connection for ${connection.name} (Account: ${connection.account})`);
         // Validate required fields
@@ -226,7 +254,7 @@ class SnowflakeConnector {
         let conn = null;
         try {
             conn = await this.createConnection(connection);
-            await this.executeQuery(conn, 'SELECT CURRENT_VERSION()');
+            await this.executeInternal(conn, 'SELECT CURRENT_VERSION()');
             console.log(`[Snowflake] Connection test successful for ${connection.name}`);
             return true;
         }
@@ -244,7 +272,7 @@ class SnowflakeConnector {
         let conn = null;
         try {
             conn = await this.createConnection(connection);
-            const rows = await this.executeQuery(conn, 'SHOW TABLES');
+            const rows = await this.executeInternal(conn, 'SHOW TABLES');
             return rows.map((row) => ({
                 name: row.name || row.TABLE_NAME,
                 type: 'table',
@@ -266,9 +294,9 @@ class SnowflakeConnector {
         try {
             conn = await this.createConnection(connection);
             const offset = (page - 1) * limit;
-            const countRows = await this.executeQuery(conn, `SELECT COUNT(*) as TOTAL FROM "${tableName}"`);
+            const countRows = await this.executeInternal(conn, `SELECT COUNT(*) as TOTAL FROM "${tableName}"`);
             const totalRows = countRows[0]?.TOTAL || 0;
-            const rows = await this.executeQuery(conn, `SELECT * FROM "${tableName}" LIMIT ${limit} OFFSET ${offset}`);
+            const rows = await this.executeInternal(conn, `SELECT * FROM "${tableName}" LIMIT ${limit} OFFSET ${offset}`);
             const columns = rows.length > 0 ? Object.keys(rows[0]) : [];
             const totalPages = Math.ceil(totalRows / limit) || 1;
             return {
@@ -298,7 +326,7 @@ class SnowflakeConnector {
         let conn = null;
         try {
             conn = await this.createConnection(connection);
-            const rows = await this.executeQuery(conn, `DESCRIBE TABLE "${tableName}"`);
+            const rows = await this.executeInternal(conn, `DESCRIBE TABLE "${tableName}"`);
             return rows.map((row) => ({
                 name: row.name || row.COLUMN_NAME,
                 type: row.type || row.DATA_TYPE,

package/dist/connectors/index.d.ts

@@ -28,6 +28,7 @@ export interface Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery?(connection: Connection, query: string): Promise<any[]>;
 }
 export declare class ConnectorRegistry {
     private static connectors;

package/dist/connectors/mysql/index.d.ts

@@ -7,4 +7,5 @@ export declare class MySQLConnector implements Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<import('../index').ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
 }

package/dist/connectors/mysql/index.js

@@ -178,5 +178,28 @@ finally:
         }
         return `# Language ${lang} not supported for MySQL connector yet.`;
     }
+    async executeQuery(connection, query) {
+        console.log(`[MySQL] executeQuery called for ${connection.name}`);
+        let conn = null;
+        try {
+            conn = await promise_1.default.createConnection({
+                host: connection.host,
+                port: connection.port || 3306,
+                user: connection.user,
+                password: connection.password || '',
+                database: connection.database
+            });
+            const [rows] = await conn.execute(query);
+            return rows;
+        }
+        catch (error) {
+            console.error(`[MySQL] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+        finally {
+            if (conn)
+                await conn.end();
+        }
+    }
 }
 exports.MySQLConnector = MySQLConnector;

package/dist/connectors/postgresql/index.d.ts

@@ -8,4 +8,5 @@ export declare class PostgreSQLConnector implements Connector {
     getData(connection: Connection, tableName: string, page: number, limit: number): Promise<TableData>;
     getSchema(connection: Connection, tableName: string): Promise<import('../index').ColumnInfo[]>;
     getSnippet(connection: Connection, lang: string): string;
+    executeQuery(connection: Connection, query: string): Promise<any[]>;
 }

package/dist/connectors/postgresql/index.js

@@ -156,5 +156,21 @@ finally:
         }
         return `# Language ${lang} not supported for PostgreSQL connector yet.`;
     }
+    async executeQuery(connection, query) {
+        console.log(`[PostgreSQL] executeQuery called for ${connection.name}`);
+        const client = this.createClient(connection);
+        try {
+            await client.connect();
+            const result = await client.query(query);
+            return result.rows;
+        }
+        catch (error) {
+            console.error(`[PostgreSQL] executeQuery failed:`, error.message);
+            throw new Error(`Failed to execute query: ${error.message}`);
+        }
+        finally {
+            await client.end();
+        }
+    }
 }
 exports.PostgreSQLConnector = PostgreSQLConnector;

package/dist/routes/dashboard.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const query_executor_1 = require("../services/query-executor");
 const router = (0, express_1.Router)();
 // Get reports/dashboards directory path relative to current working directory
 function getDashboardsDir() {
@@ -82,7 +83,7 @@ router.get('/dashboards/:id', (req, res) => {
             return res.status(404).json({ error: 'Dashboard not found' });
         }
         const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-        res.json(content);
+        res.json({ id, ...content });
     }
     catch (error) {
         console.error('Error reading dashboard:', error);
@@ -90,24 +91,76 @@ router.get('/dashboards/:id', (req, res) => {
     }
 });
 // Refresh a chart's data (placeholder for now - would re-run query)
-router.post('/charts/:id/refresh', (req, res) => {
+router.post('/charts/:id/refresh', async (req, res) => {
     try {
         const { id } = req.params;
-        // For now, just return a success message
-        // In the future, this would:
-        // 1. Find the chart in a dashboard
-        // 2. Re-run its query against the data source
-        // 3. Update the chart data
-        // 4. Save the updated dashboard
-        res.json({
-            message: 'Refresh not yet implemented',
-            chartId: id,
-            lastRefreshed: new Date().toISOString()
-        });
+        const dashboardsDir = getDashboardsDir();
+        // 1. Find the chart in any dashboard
+        // We have to search all dashboards because we don't know which one calls it
+        // In a real DB we'd have a chart table, but here we scan JSONs
+        const files = fs.readdirSync(dashboardsDir).filter(file => file.endsWith('.json'));
+        let targetDashboard = null;
+        let targetDashboardFile = '';
+        let targetChart = null;
+        for (const file of files) {
+            const filePath = path.join(dashboardsDir, file);
+            const dashboard = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            const chart = dashboard.charts.find(c => c.id === id);
+            if (chart) {
+                targetDashboard = dashboard;
+                targetDashboardFile = filePath;
+                targetChart = chart;
+                break;
+            }
+        }
+        if (!targetDashboard || !targetChart || !targetDashboardFile) {
+            return res.status(404).json({ error: 'Chart not found' });
+        }
+        // 2. Execute Query
+        if (!targetChart.query || !targetChart.query.connection) {
+            return res.status(400).json({ error: 'Chart has no query configuration' });
+        }
+        console.log(`Refreshing chart ${id} using connection ${targetChart.query.connection}...`);
+        const newData = await query_executor_1.QueryExecutor.execute(targetChart.query);
+        // 3. Update Dashboard
+        targetChart.data = newData;
+        targetChart.lastRefreshed = new Date().toISOString();
+        // Save back to disk
+        fs.writeFileSync(targetDashboardFile, JSON.stringify(targetDashboard, null, 2));
+        // 4. Return new data
+        res.json(targetChart);
     }
     catch (error) {
         console.error('Error refreshing chart:', error);
-        res.status(500).json({ error: 'Failed to refresh chart' });
+        res.status(500).json({ error: error instanceof Error ? error.message : 'Failed to refresh chart' });
+    }
+});
+// SSE Endpoint for file watching
+router.get('/events', (req, res) => {
+    // Set headers for SSE
+    res.setHeader('Content-Type', 'text/event-stream');
+    res.setHeader('Cache-Control', 'no-cache');
+    res.setHeader('Connection', 'keep-alive');
+    res.flushHeaders();
+    const dashboardsDir = getDashboardsDir();
+    if (!fs.existsSync(dashboardsDir)) {
+        return res.end();
     }
+    console.log('Client connected to SSE stream');
+    // Watch for file changes
+    const watcher = fs.watch(dashboardsDir, (eventType, filename) => {
+        if (filename && filename.endsWith('.json')) {
+            console.log(`File changed: ${filename} (${eventType})`);
+            const dashboardId = path.basename(filename, '.json');
+            // Send event
+            res.write(`data: ${JSON.stringify({ type: 'dashboard-update', id: dashboardId })}\n\n`);
+        }
+    });
+    // Cleanup on close
+    req.on('close', () => {
+        watcher.close();
+        console.log('Client disconnected from SSE stream');
+        res.end();
+    });
 });
 exports.default = router;

package/dist/services/query-executor.d.ts

@@ -0,0 +1,5 @@
+import { ChartQuery, ChartData } from '../types/dashboard';
+export declare class QueryExecutor {
+    static execute(query: ChartQuery): Promise<ChartData>;
+    private static transformToChartData;
+}

package/dist/services/query-executor.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryExecutor = void 0;
+const connections_1 = require("../connections");
+const postgresql_1 = require("../connectors/postgresql");
+const mysql_1 = require("../connectors/mysql");
+// import { BigQueryConnector } from '../connectors/bigquery';
+// import { SnowflakeConnector } from '../connectors/snowflake';
+const shopify_1 = require("../connectors/shopify");
+class QueryExecutor {
+    static async execute(query) {
+        if (!query.connection) {
+            throw new Error('No connection specified in query');
+        }
+        const connectionConfig = (0, connections_1.getConnection)(query.connection);
+        if (!connectionConfig) {
+            throw new Error(`Connection "${query.connection}" not found`);
+        }
+        let result;
+        // Execute query based on connection type
+        switch (connectionConfig.type) {
+            case 'postgresql': {
+                const connector = new postgresql_1.PostgreSQLConnector();
+                if (!query.sql)
+                    throw new Error('SQL query required for Postgres');
+                result = await connector.executeQuery(connectionConfig, query.sql);
+                break;
+            }
+            case 'mysql': {
+                const connector = new mysql_1.MySQLConnector();
+                if (!query.sql)
+                    throw new Error('SQL query required for MySQL');
+                result = await connector.executeQuery(connectionConfig, query.sql);
+                break;
+            }
+            // case 'bigquery': {
+            //     const connector = new BigQueryConnector();
+            //     if (!query.sql) throw new Error('SQL query required for BigQuery');
+            //     result = await connector.executeQuery(connectionConfig, query.sql);
+            //     break;
+            // }
+            // case 'snowflake': {
+            //     const connector = new SnowflakeConnector();
+            //     if (!query.sql) throw new Error('SQL query required for Snowflake');
+            //     result = await connector.executeQuery(connectionConfig, query.sql);
+            //     break;
+            // }
+            case 'shopify': {
+                const connector = new shopify_1.ShopifyConnector();
+                // For Shopify, query.sql is treated as the table name/endpoint
+                const tableName = query.sql?.trim() || 'orders';
+                // Fetch first page, limit 1000
+                const tableData = await connector.getData(connectionConfig, tableName, 1, 1000);
+                result = tableData.rows;
+                break;
+            }
+            default:
+                throw new Error(`Unsupported connection type: ${connectionConfig.type}`);
+        }
+        // Transform result to ChartData format
+        return this.transformToChartData(result, query);
+    }
+    static transformToChartData(data, query) {
+        if (!data || data.length === 0) {
+            return { labels: [], datasets: [] };
+        }
+        // Auto-detect labels (first string/date column)
+        const keys = Object.keys(data[0]);
+        const labelKey = keys.find(k => typeof data[0][k] === 'string' || data[0][k] instanceof Date) || keys[0];
+        const labels = data.map(row => String(row[labelKey]));
+        // Create datasets for all numeric columns
+        const valueKeys = keys.filter(k => k !== labelKey && typeof data[0][k] === 'number');
+        const datasets = valueKeys.map((key, i) => ({
+            label: key.charAt(0).toUpperCase() + key.slice(1).replace(/_/g, ' '),
+            values: data.map(row => Number(row[key]))
+        }));
+        return { labels, datasets };
+    }
+}
+exports.QueryExecutor = QueryExecutor;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "crushdataai",
-    "version": "1.2.14",
+    "version": "1.2.15",
     "description": "CLI to install CrushData AI data analyst skill for AI coding assistants",
     "main": "dist/index.js",
     "bin": {