@claryai/cli 0.1.0

package/dist/handlers/runChart.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChartHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const yaml = tslib_1.__importStar(require("js-yaml"));
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const asyncQuery_1 = require("./asyncQuery");
+const apiClient_1 = require("./dbt/apiClient");
+const DEFAULT_PAGE_SIZE = 500;
+const runChartHandler = async (options) => {
+    globalState_1.default.setVerbose(options.verbose ?? false);
+    // Read and parse YAML
+    let fileContent;
+    try {
+        fileContent = await fs_1.promises.readFile(options.path, 'utf-8');
+    }
+    catch (err) {
+        throw new Error(`Cannot read file: ${options.path}`);
+    }
+    let chart;
+    try {
+        chart = yaml.load(fileContent);
+    }
+    catch (err) {
+        throw new Error(`Invalid YAML in ${options.path}`);
+    }
+    // Validate it's a metric query chart (not SQL)
+    const typedChart = chart;
+    if ('sql' in typedChart && !('tableName' in typedChart)) {
+        throw new Error('SQL charts are not supported. Only metric query charts (with tableName + metricQuery) can be run.');
+    }
+    if (!typedChart.tableName || !typedChart.metricQuery) {
+        throw new Error(`File is not a valid metric query chart. Expected 'tableName' and 'metricQuery' fields.`);
+    }
+    const chartAsCode = chart;
+    // Get project UUID
+    const config = await (0, config_1.getConfig)();
+    const projectUuid = config.context?.project;
+    if (!projectUuid) {
+        throw new Error(`No project selected. Run 'clary config set-project' first.`);
+    }
+    const chartName = chartAsCode.name ?? chartAsCode.slug ?? options.path;
+    globalState_1.default.debug(`> Running chart: ${chartName}`);
+    globalState_1.default.debug(`> Table: ${chartAsCode.tableName}`);
+    globalState_1.default.debug(`> Project: ${projectUuid}`);
+    const spinner = globalState_1.default.startSpinner(`Executing query for '${chartName}'...`);
+    const { metricQuery } = chartAsCode;
+    // Build request body: convert MetricQuery to MetricQueryRequest shape
+    const queryBody = {
+        exploreName: chartAsCode.tableName,
+        dimensions: metricQuery.dimensions,
+        metrics: metricQuery.metrics,
+        filters: metricQuery.filters,
+        sorts: metricQuery.sorts,
+        limit: options.limit ?? metricQuery.limit,
+        tableCalculations: metricQuery.tableCalculations,
+        additionalMetrics: metricQuery.additionalMetrics,
+        customDimensions: metricQuery.customDimensions,
+    };
+    // Submit metric query
+    const submitResult = await (0, apiClient_1.lightdashApi)({
+        method: 'POST',
+        url: `/api/v2/projects/${projectUuid}/query/metric-query`,
+        body: JSON.stringify({
+            query: queryBody,
+            context: 'cli',
+        }),
+    });
+    globalState_1.default.debug(`> Query UUID: ${submitResult.queryUuid}`);
+    spinner.text = 'Waiting for query results...';
+    // Poll for completion
+    const result = await (0, asyncQuery_1.pollForResults)(projectUuid, submitResult.queryUuid, {
+        pageSize: options.output
+            ? (options.pageSize ?? DEFAULT_PAGE_SIZE)
+            : undefined,
+    });
+    if (result.status === common_1.QueryHistoryStatus.ERROR) {
+        spinner.fail(`Query failed for '${chartName}'\n Make sure all semantic layer fields referenced in the metric query (dimensions, metrics, custom dimensions, etc.) are deployed to the Clary project.`);
+        throw new Error(result.error ?? 'Query execution failed');
+    }
+    if (result.status === common_1.QueryHistoryStatus.CANCELLED) {
+        spinner.fail(`Query cancelled for '${chartName}'`);
+        throw new Error('Query was cancelled');
+    }
+    if (result.status !== common_1.QueryHistoryStatus.READY) {
+        spinner.fail('Unexpected query status');
+        throw new Error(`Unexpected query status: ${result.status}`);
+    }
+    const durationMs = result.initialQueryExecutionMs;
+    const durationStr = durationMs ? ` (${durationMs}ms)` : '';
+    if (options.output) {
+        const columns = Object.keys(result.columns);
+        const csv = (0, asyncQuery_1.resultsToCsv)(columns, result.rows);
+        await fs_1.promises.writeFile(options.output, csv, 'utf8');
+        spinner.succeed(`${styles.success('Success!')} Wrote ${result.rows.length} rows to ${options.output}${durationStr}`);
+    }
+    else {
+        spinner.succeed(`${styles.success('Success!')} '${chartName}' query succeeded${durationStr}`);
+    }
+};
+exports.runChartHandler = runChartHandler;

package/dist/handlers/selectProject.d.ts

@@ -0,0 +1,20 @@
+import { Config } from '../config';
+export type ProjectSelection = {
+    projectUuid: string;
+    isPreview: boolean;
+};
+/**
+ * Resolves which project to use, prompting the user if there's an active preview.
+ *
+ * Priority:
+ * 1. If `explicitProject` is provided (via --project flag), use it
+ * 2. If there's an active preview and we're in interactive mode, ask the user
+ * 3. In non-interactive mode with active preview, use preview project
+ * 4. Fall back to the main project
+ */
+export declare const selectProject: (config: Config, explicitProject?: string) => Promise<ProjectSelection | undefined>;
+/**
+ * Logs which project is being used
+ */
+export declare const logSelectedProject: (selection: ProjectSelection, config: Config, action: string) => void;
+//# sourceMappingURL=selectProject.d.ts.map

package/dist/handlers/selectProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selectProject.d.ts","sourceRoot":"","sources":["../../src/handlers/selectProject.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAInC,MAAM,MAAM,gBAAgB,GAAG;IAC3B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GACtB,QAAQ,MAAM,EACd,kBAAkB,MAAM,KACzB,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAsEtC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC3B,WAAW,gBAAgB,EAC3B,QAAQ,MAAM,EACd,QAAQ,MAAM,KACf,IAcF,CAAC"}

package/dist/handlers/selectProject.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logSelectedProject = exports.selectProject = void 0;
+const tslib_1 = require("tslib");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+/**
+ * Resolves which project to use, prompting the user if there's an active preview.
+ *
+ * Priority:
+ * 1. If `explicitProject` is provided (via --project flag), use it
+ * 2. If there's an active preview and we're in interactive mode, ask the user
+ * 3. In non-interactive mode with active preview, use preview project
+ * 4. Fall back to the main project
+ */
+const selectProject = async (config, explicitProject) => {
+    // If explicit project provided via --project flag, use it
+    if (explicitProject) {
+        return { projectUuid: explicitProject, isPreview: false };
+    }
+    const mainProject = config.context?.project;
+    const previewProject = config.context?.previewProject;
+    const previewName = config.context?.previewName;
+    const mainProjectName = config.context?.projectName;
+    // No projects configured at all
+    if (!mainProject && !previewProject) {
+        return undefined;
+    }
+    // Only preview project available (edge case, but handle it)
+    if (!mainProject && previewProject) {
+        return { projectUuid: previewProject, isPreview: true };
+    }
+    // Only main project available (no active preview)
+    if (mainProject && !previewProject) {
+        return { projectUuid: mainProject, isPreview: false };
+    }
+    // Both are available - need to choose
+    if (mainProject && previewProject) {
+        // In non-interactive mode, default to preview project
+        if (globalState_1.default.isNonInteractive()) {
+            globalState_1.default.debug('> Non-interactive mode with active preview, using preview project');
+            return { projectUuid: previewProject, isPreview: true };
+        }
+        // Interactive mode - ask the user
+        const spinner = globalState_1.default.getActiveSpinner();
+        spinner?.stop();
+        const previewLabel = previewName
+            ? `Preview: "${previewName}"`
+            : `Preview: ${previewProject}`;
+        const mainLabel = mainProjectName
+            ? `Production: "${mainProjectName}"`
+            : `Production: ${mainProject}`;
+        const { selectedProject } = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'selectedProject',
+                message: 'You have an active preview. Which project do you want to use?',
+                choices: [
+                    { name: previewLabel, value: 'preview' },
+                    { name: mainLabel, value: 'production' },
+                ],
+                default: 'preview',
+            },
+        ]);
+        spinner?.start();
+        if (selectedProject === 'preview') {
+            return { projectUuid: previewProject, isPreview: true };
+        }
+        return { projectUuid: mainProject, isPreview: false };
+    }
+    return undefined;
+};
+exports.selectProject = selectProject;
+/**
+ * Logs which project is being used
+ */
+const logSelectedProject = (selection, config, action) => {
+    const { projectUuid, isPreview } = selection;
+    const previewName = config.context?.previewName;
+    const mainProjectName = config.context?.projectName;
+    if (isPreview) {
+        const name = previewName ? `"${previewName}"` : projectUuid;
+        globalState_1.default.log(`\n${styles.success(`${action} preview project:`)} ${name}\n`);
+    }
+    else {
+        const name = mainProjectName ? `"${mainProjectName}"` : projectUuid;
+        globalState_1.default.log(`\n${styles.success(`${action} project:`)} ${name}\n`);
+    }
+};
+exports.logSelectedProject = logSelectedProject;

package/dist/handlers/setProject.d.ts

@@ -0,0 +1,14 @@
+type SetProjectOptions = {
+    verbose: boolean;
+    name: string;
+    uuid: string;
+};
+export declare const setProjectCommand: (name?: string, uuid?: string) => Promise<"selected" | "skipped" | "empty">;
+export declare const setFirstProject: () => Promise<void>;
+export declare const setProjectHandler: (options: SetProjectOptions) => Promise<void>;
+export declare const unsetProjectCommand: () => Promise<void>;
+export declare const unsetProjectHandler: (options: {
+    verbose: boolean;
+}) => Promise<void>;
+export {};
+//# sourceMappingURL=setProject.d.ts.map

package/dist/handlers/setProject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setProject.d.ts","sourceRoot":"","sources":["../../src/handlers/setProject.ts"],"names":[],"mappings":"AAQA,KAAK,iBAAiB,GAAG;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC1B,OAAO,MAAM,EACb,OAAO,MAAM,KACd,OAAO,CAAC,UAAU,GAAG,SAAS,GAAG,OAAO,CAmE1C,CAAC;AAEF,eAAO,MAAM,eAAe,qBAmB3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,SAAS,iBAAiB,kBAsBjE,CAAC;AAEF,eAAO,MAAM,mBAAmB,qBAG/B,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAU,SAAS;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,kBAmBtE,CAAC"}

package/dist/handlers/setProject.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unsetProjectHandler = exports.unsetProjectCommand = exports.setProjectHandler = exports.setFirstProject = exports.setProjectCommand = void 0;
+const tslib_1 = require("tslib");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const url_1 = require("url");
+const analytics_1 = require("../analytics/analytics");
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const apiClient_1 = require("./dbt/apiClient");
+const setProjectCommand = async (name, uuid) => {
+    const projects = await (0, apiClient_1.lightdashApi)({
+        method: 'GET',
+        url: `/api/v1/org/projects`,
+        body: undefined,
+    });
+    globalState_1.default.debug(`> Set project returned response: ${JSON.stringify(projects)}`);
+    if (projects.length === 0)
+        return 'empty';
+    let selectedProject;
+    // --uuid or --name options
+    if (uuid !== undefined || name !== undefined) {
+        selectedProject = projects.find((project) => project.name === name || project.projectUuid === uuid);
+    }
+    else if (globalState_1.default.isNonInteractive()) {
+        globalState_1.default.debug('> Non-interactive mode: selecting first project');
+        [selectedProject] = projects;
+    }
+    else {
+        const SKIP_VALUE = '__skip__';
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'project',
+                choices: [
+                    {
+                        name: "Don't select a project",
+                        value: SKIP_VALUE,
+                    },
+                    ...projects.map((project) => ({
+                        name: project.name,
+                        value: project.projectUuid,
+                    })),
+                ],
+            },
+        ]);
+        if (answers.project === SKIP_VALUE) {
+            await (0, config_1.unsetProject)();
+            return 'skipped';
+        }
+        selectedProject = projects.find((project) => project.projectUuid === answers.project);
+    }
+    if (selectedProject !== undefined) {
+        await (0, config_1.setProject)(selectedProject.projectUuid, selectedProject.name);
+        const config = await (0, config_1.getConfig)();
+        const projectUrl = config.context?.serverUrl &&
+            new url_1.URL(`/projects/${selectedProject.projectUuid}/home`, config.context.serverUrl);
+        console.error(`\n  ✅️ Connected to Clary project: ${projectUrl || ''}\n`);
+        return 'selected';
+    }
+    throw new Error(`Project not found.`);
+};
+exports.setProjectCommand = setProjectCommand;
+const setFirstProject = async () => {
+    const projects = await (0, apiClient_1.lightdashApi)({
+        method: 'GET',
+        url: `/api/v1/org/projects`,
+        body: undefined,
+    });
+    const firstProject = projects[0];
+    await (0, config_1.setProject)(firstProject.projectUuid, firstProject.name);
+    const config = await (0, config_1.getConfig)();
+    const projectUrl = config.context?.serverUrl &&
+        new url_1.URL(`/projects/${firstProject.name}/home`, config.context.serverUrl);
+    console.error(`\n  ✅️ Connected to Clary project: ${projectUrl || ''}\n`);
+};
+exports.setFirstProject = setFirstProject;
+const setProjectHandler = async (options) => {
+    const startTime = Date.now();
+    let success = true;
+    globalState_1.default.setVerbose(options.verbose);
+    try {
+        const result = await (0, exports.setProjectCommand)(options.name, options.uuid);
+        if (result === 'skipped') {
+            console.error(`\n  Project unset.\n`);
+        }
+    }
+    catch (e) {
+        success = false;
+        throw e;
+    }
+    finally {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'command.executed',
+            properties: {
+                command: 'set-project',
+                durationMs: Date.now() - startTime,
+                success,
+            },
+        });
+    }
+};
+exports.setProjectHandler = setProjectHandler;
+const unsetProjectCommand = async () => {
+    await (0, config_1.unsetProject)();
+    console.error(`\n  Project unset.\n`);
+};
+exports.unsetProjectCommand = unsetProjectCommand;
+const unsetProjectHandler = async (options) => {
+    const startTime = Date.now();
+    let success = true;
+    globalState_1.default.setVerbose(options.verbose);
+    try {
+        await (0, exports.unsetProjectCommand)();
+    }
+    catch (e) {
+        success = false;
+        throw e;
+    }
+    finally {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'command.executed',
+            properties: {
+                command: 'unset-project',
+                durationMs: Date.now() - startTime,
+                success,
+            },
+        });
+    }
+};
+exports.unsetProjectHandler = unsetProjectHandler;

package/dist/handlers/setWarehouse.d.ts

@@ -0,0 +1,14 @@
+type SetWarehouseHandlerOptions = {
+    projectDir: string;
+    profilesDir: string;
+    target?: string;
+    profile?: string;
+    targetPath?: string;
+    project?: string;
+    startOfWeek?: number;
+    assumeYes: boolean;
+    verbose: boolean;
+};
+export declare const setWarehouseHandler: (options: SetWarehouseHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=setWarehouse.d.ts.map

package/dist/handlers/setWarehouse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setWarehouse.d.ts","sourceRoot":"","sources":["../../src/handlers/setWarehouse.ts"],"names":[],"mappings":"AAaA,KAAK,0BAA0B,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CACpB,CAAC;AAeF,eAAO,MAAM,mBAAmB,GAC5B,SAAS,0BAA0B,kBAyFtC,CAAC"}

package/dist/handlers/setWarehouse.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setWarehouseHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const createProject_1 = require("./createProject");
+const apiClient_1 = require("./dbt/apiClient");
+const refresh_1 = require("./dbt/refresh");
+const resolveProjectUuid = async (projectOption) => {
+    if (projectOption) {
+        return projectOption;
+    }
+    const config = await (0, config_1.getConfig)();
+    if (!config.context?.project) {
+        throw new common_1.AuthorizationError(`No project selected. Run 'clary config set-project' first or pass '--project <uuid>'.`);
+    }
+    return config.context.project;
+};
+const setWarehouseHandler = async (options) => {
+    globalState_1.default.setVerbose(options.verbose);
+    await (0, apiClient_1.checkLightdashVersion)();
+    const projectUuid = await resolveProjectUuid(options.project);
+    // Load credentials from profiles.yml
+    const loaded = await (0, createProject_1.loadWarehouseCredentialsFromProfiles)({
+        projectDir: options.projectDir,
+        profilesDir: options.profilesDir,
+        target: options.target,
+        profile: options.profile,
+        startOfWeek: options.startOfWeek,
+        assumeYes: options.assumeYes,
+        targetPath: options.targetPath,
+    });
+    if (!loaded) {
+        console.error(styles.warning('User declined to store warehouse credentials. Use --assume-yes to bypass.'));
+        return;
+    }
+    const { credentials } = loaded;
+    // Fetch existing project to preserve its settings
+    const existingProject = await (0, refresh_1.getProject)(projectUuid);
+    // Confirmation prompt
+    if (!options.assumeYes && !globalState_1.default.isNonInteractive()) {
+        const spinner = globalState_1.default.getActiveSpinner();
+        spinner?.stop();
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'isConfirm',
+                message: `This will update the warehouse connection on project '${existingProject.name}' to ${credentials.type} and trigger a recompile. Continue?`,
+                default: false,
+            },
+        ]);
+        if (!answers.isConfirm) {
+            console.error(styles.warning('Aborted.'));
+            return;
+        }
+        spinner?.start();
+    }
+    const spinner = globalState_1.default.startSpinner('  Updating warehouse connection...');
+    try {
+        // Build UpdateProject body — preserve existing fields, override warehouseConnection.
+        // Note: dbtConnection from GET response may have stripped secrets, but the backend's
+        // mergeMissingProjectConfigSecrets fills them back in from the saved project before persisting.
+        const updateBody = {
+            name: existingProject.name,
+            dbtConnection: existingProject.dbtConnection,
+            dbtVersion: existingProject.dbtVersion,
+            warehouseConnection: credentials,
+        };
+        // PATCH project — triggers adaptor test + recompile
+        const result = await (0, apiClient_1.lightdashApi)({
+            method: 'PATCH',
+            url: `/api/v1/projects/${projectUuid}`,
+            body: JSON.stringify(updateBody),
+        });
+        // Poll until job completes (custom spinner prefix)
+        await (0, refresh_1.getFinalJobState)(result.jobUuid, 'Updating warehouse connection');
+        spinner.stop();
+    }
+    catch (e) {
+        spinner.fail();
+        throw e;
+    }
+    const config = await (0, config_1.getConfig)();
+    const displayUrl = `${config.context?.serverUrl}/projects/${projectUuid}/home`;
+    console.error(`${styles.bold('Successfully updated warehouse connection:')}`);
+    console.error('');
+    console.error(`      ${styles.bold(`⚡️ ${displayUrl}`)}`);
+    console.error('');
+};
+exports.setWarehouseHandler = setWarehouseHandler;

package/dist/handlers/sql.d.ts

@@ -0,0 +1,9 @@
+type SqlHandlerOptions = {
+    output: string;
+    limit?: number;
+    pageSize?: number;
+    verbose?: boolean;
+};
+export declare const sqlHandler: (sql: string, options: SqlHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=sql.d.ts.map

package/dist/handlers/sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql.d.ts","sourceRoot":"","sources":["../../src/handlers/sql.ts"],"names":[],"mappings":"AAcA,KAAK,iBAAiB,GAAG;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAKF,eAAO,MAAM,UAAU,GACnB,KAAK,MAAM,EACX,SAAS,iBAAiB,KAC3B,OAAO,CAAC,IAAI,CAqGd,CAAC"}

package/dist/handlers/sql.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const fs_1 = require("fs");
+const uuid_1 = require("uuid");
+const analytics_1 = require("../analytics/analytics");
+const config_1 = require("../config");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const styles = tslib_1.__importStar(require("../styles"));
+const asyncQuery_1 = require("./asyncQuery");
+const apiClient_1 = require("./dbt/apiClient");
+const DEFAULT_PAGE_SIZE = 500;
+const DEFAULT_LIMIT = 50000;
+const sqlHandler = async (sql, options) => {
+    globalState_1.default.setVerbose(options.verbose ?? false);
+    const executionId = (0, uuid_1.v4)();
+    const startTime = Date.now();
+    const config = await (0, config_1.getConfig)();
+    const projectUuid = config.context?.project;
+    if (!projectUuid) {
+        throw new Error(`No project selected. Run 'clary config set-project' first.`);
+    }
+    globalState_1.default.debug(`> Running SQL query against project: ${projectUuid}`);
+    globalState_1.default.debug(`> SQL: ${sql}`);
+    const pageSize = options.pageSize ?? DEFAULT_PAGE_SIZE;
+    try {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'sql.started',
+            properties: {
+                executionId,
+                projectId: projectUuid,
+            },
+        });
+        const spinner = globalState_1.default.startSpinner('Submitting SQL query...');
+        const limit = options.limit ?? DEFAULT_LIMIT;
+        const submitResult = await (0, apiClient_1.lightdashApi)({
+            method: 'POST',
+            url: `/api/v2/projects/${projectUuid}/query/sql`,
+            body: JSON.stringify({
+                sql,
+                limit,
+                context: 'cli',
+            }),
+        });
+        globalState_1.default.debug(`> Query UUID: ${submitResult.queryUuid}`);
+        spinner.text = 'Waiting for query results...';
+        const result = await (0, asyncQuery_1.pollForResults)(projectUuid, submitResult.queryUuid, {
+            pageSize,
+        });
+        if (result.status === common_1.QueryHistoryStatus.ERROR) {
+            spinner.fail('Query failed');
+            throw new Error(result.error ?? 'Query execution failed');
+        }
+        if (result.status !== common_1.QueryHistoryStatus.READY) {
+            spinner.fail('Unexpected query status');
+            throw new Error(`Unexpected query status: ${result.status}`);
+        }
+        const columns = Object.keys(result.columns);
+        const rowCount = result.rows.length;
+        spinner.text = `Writing ${rowCount} rows to ${options.output}...`;
+        const csv = (0, asyncQuery_1.resultsToCsv)(columns, result.rows);
+        await fs_1.promises.writeFile(options.output, csv, 'utf8');
+        spinner.succeed(`${styles.success('Success!')} Wrote ${rowCount} rows to ${options.output}`);
+        await analytics_1.LightdashAnalytics.track({
+            event: 'sql.completed',
+            properties: {
+                executionId,
+                projectId: projectUuid,
+                rowCount,
+                columnCount: columns.length,
+                durationMs: Date.now() - startTime,
+            },
+        });
+    }
+    catch (e) {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'sql.error',
+            properties: {
+                executionId,
+                error: (0, common_1.getErrorMessage)(e),
+                errorCategory: (0, analytics_1.categorizeError)(e),
+            },
+        });
+        throw e;
+    }
+};
+exports.sqlHandler = sqlHandler;

package/dist/handlers/utils.d.ts

@@ -0,0 +1,11 @@
+import { LightdashRequestMethodHeader, RequestMethod } from '@lightdash/common';
+type RequestHeader = {
+    'Content-Type': 'application/json';
+    'Content-Encoding'?: string;
+    Authorization: string;
+    'Proxy-Authorization'?: string;
+    [LightdashRequestMethodHeader]: RequestMethod;
+};
+export declare function buildRequestHeaders(token: string): RequestHeader;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/handlers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/handlers/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,4BAA4B,EAC5B,aAAa,EAChB,MAAM,mBAAmB,CAAC;AAO3B,KAAK,aAAa,GAAG;IACjB,cAAc,EAAE,kBAAkB,CAAC;IACnC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,CAAC,4BAA4B,CAAC,EAAE,aAAa,CAAC;CACjD,CAAC;AAgBF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,iBAgBhD"}

package/dist/handlers/utils.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRequestHeaders = buildRequestHeaders;
+const common_1 = require("@lightdash/common");
+var TokenType;
+(function (TokenType) {
+    TokenType["ApiKey"] = "ApiKey";
+    TokenType["Bearer"] = "Bearer";
+})(TokenType || (TokenType = {}));
+/**
+ * We initially used personal access tokens (PATs) for CLI authentication without any prefix.
+ * Service account tokens are launching with a prefix, so we'll check them first.
+ * We assume a missing prefix is a personal access token, although new PATs will be created with a prefix.
+ *
+ * See {@link AuthTokenPrefix} for the available token prefixes
+ */
+function getAuthHeader(token) {
+    const authType = token?.startsWith(common_1.AuthTokenPrefix.SERVICE_ACCOUNT)
+        ? TokenType.Bearer
+        : TokenType.ApiKey;
+    return `${authType} ${token}`;
+}
+function buildRequestHeaders(token) {
+    const headers = {
+        'Content-Type': 'application/json',
+        Authorization: getAuthHeader(token),
+        [common_1.LightdashRequestMethodHeader]: process.env.CI === 'true'
+            ? common_1.RequestMethod.CLI_CI
+            : common_1.RequestMethod.CLI,
+    };
+    if (process.env.CLARY_PROXY_AUTHORIZATION) {
+        headers['Proxy-Authorization'] =
+            process.env.CLARY_PROXY_AUTHORIZATION;
+    }
+    return headers;
+}

package/dist/handlers/validate.d.ts

@@ -0,0 +1,22 @@
+import { Explore, ExploreError, SchedulerJobStatus, ValidationTarget } from '@lightdash/common';
+import { CompileHandlerOptions } from './compile';
+export declare const requestValidation: (projectUuid: string, explores: (Explore | ExploreError)[], validationTargets: ValidationTarget[]) => Promise<{
+    jobId: string;
+}>;
+export declare const getJobState: (jobUuid: string) => Promise<{
+    status: SchedulerJobStatus;
+    details: Record<string, import("@lightdash/common").AnyType> | null;
+}>;
+export declare const getValidation: (projectUuid: string, jobId: string) => Promise<import("@lightdash/common").ValidationResponse[]>;
+export declare function delay(ms: number): Promise<unknown>;
+type ValidateHandlerOptions = CompileHandlerOptions & {
+    project?: string;
+    verbose: boolean;
+    preview: boolean;
+    only: ValidationTarget[];
+    showChartConfigurationWarnings: boolean;
+};
+export declare const waitUntilFinished: (jobUuid: string) => Promise<string>;
+export declare const validateHandler: (options: ValidateHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=validate.d.ts.map