crushdataai 1.2.13 → 1.2.15

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/dist/types/dashboard.d.ts

@@ -0,0 +1,48 @@
+export interface DashboardMetadata {
+    title: string;
+    generatedAt: string;
+    dataRange?: string;
+    recordCount?: number;
+}
+export interface KPI {
+    id: string;
+    label: string;
+    value: string;
+    trend?: string;
+    trendDirection?: 'up' | 'down' | 'neutral';
+}
+export interface ChartQuery {
+    type: 'sql' | 'api';
+    connection?: string;
+    sql?: string;
+}
+export interface ChartDataset {
+    label: string;
+    values: number[];
+    color?: string;
+}
+export interface ChartData {
+    labels: string[];
+    datasets: ChartDataset[];
+}
+export interface Chart {
+    id: string;
+    type: string;
+    title: string;
+    description?: string;
+    query?: ChartQuery;
+    data: ChartData;
+    lastRefreshed?: string;
+}
+export interface Dashboard {
+    metadata: DashboardMetadata;
+    kpis: KPI[];
+    charts: Chart[];
+}
+export interface DashboardListItem {
+    id: string;
+    title: string;
+    generatedAt: string;
+    chartCount: number;
+    kpiCount: number;
+}

package/dist/types/dashboard.js

@@ -0,0 +1,3 @@
+"use strict";
+// Dashboard types for the API layer
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "crushdataai",
-    "version": "1.2.13",
+    "version": "1.2.15",
     "description": "CLI to install CrushData AI data analyst skill for AI coding assistants",
     "main": "dist/index.js",
     "bin": {
         "crushdataai": "./dist/index.js"
     },
     "scripts": {
-        "build": "tsc && cd ui-react && npm install && npm run build",
+        "build": "tsc && cd ui-react && npm install && npm run build && cd ../ui-dashboard && npm install && npm run build",
         "dev": "ts-node src/index.ts",
         "prepublishOnly": "npm run build"
     },
@@ -47,7 +47,8 @@
     "files": [
         "dist",
         "assets",
-        "ui"
+        "ui",
+        "ui-dashboard-dist"
     ],
     "repository": {
         "type": "git",