@claryai/cli 0.1.0

package/dist/handlers/dbt/getWarehouseClient.js

@@ -0,0 +1,312 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgramaticallySnowflakePat = exports.getTableSchema = void 0;
+exports.default = getWarehouseClient;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const warehouses_1 = require("@lightdash/warehouses");
+const crypto_1 = tslib_1.__importDefault(require("crypto"));
+const execa_1 = tslib_1.__importDefault(require("execa"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const config_1 = require("../../config");
+const profile_1 = require("../../dbt/profile");
+const oauth_1 = require("../../dbt/targets/Databricks/oauth");
+const globalState_1 = tslib_1.__importDefault(require("../../globalState"));
+const styles = tslib_1.__importStar(require("../../styles"));
+const apiClient_1 = require("./apiClient");
+/**
+ * Cache warehouse clients to avoid repeated authentication prompts
+ * Currently used for:
+ * - Snowflake external browser auth (avoids opening multiple browser tabs)
+ */
+const warehouseClientCache = new Map();
+/**
+ * Generates a unique cache key for warehouse credentials by hashing the credentials
+ */
+function getWarehouseClientCacheKey(credentials) {
+    // Create a hash of the stringified credentials
+    // This provides a unique key regardless of warehouse type
+    const credentialsString = JSON.stringify(credentials);
+    const hash = crypto_1.default
+        .createHash('sha256')
+        .update(credentialsString)
+        .digest('hex');
+    return hash;
+}
+const getTableSchema = async ({ projectUuid, tableName, schemaName, databaseName, }) => (0, apiClient_1.lightdashApi)({
+    method: 'GET',
+    url: `/api/v1/projects/${projectUuid}/sqlRunner/fields?tableName=${tableName}&schemaName=${schemaName}&databaseName=${databaseName}`,
+    body: undefined,
+});
+exports.getTableSchema = getTableSchema;
+const DBT_CLOUD_CONNECTION_TYPE_REGEX = /Connection type\s+(\w+)/;
+const getDbtCloudConnectionType = async () => {
+    try {
+        const { all } = await (0, execa_1.default)('dbt', ['environment', 'show'], {
+            all: true,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const logs = all || '';
+        const connectionType = logs.match(DBT_CLOUD_CONNECTION_TYPE_REGEX);
+        if (connectionType === null || connectionType.length === 0) {
+            throw new common_1.ParseError(`Can't locate connection type in 'dbt environment show' response`);
+        }
+        if (!(0, common_1.isSupportedDbtAdapterType)(connectionType[1])) {
+            throw new common_1.ParseError(`Unsupported dbt adaptor type ${connectionType[1]}`);
+        }
+        return connectionType[1];
+    }
+    catch (e) {
+        throw new common_1.ParseError(`Failed to get connection type:\n  ${(0, common_1.getErrorMessage)(e)}`);
+    }
+};
+function getMockCredentials(dbtAdaptorType) {
+    switch (dbtAdaptorType) {
+        case common_1.SupportedDbtAdapter.BIGQUERY:
+            return {
+                type: common_1.WarehouseTypes.BIGQUERY,
+                project: '',
+                dataset: '',
+                timeoutSeconds: undefined,
+                priority: undefined,
+                keyfileContents: {},
+                retries: undefined,
+                location: undefined,
+                maximumBytesBilled: undefined,
+            };
+        case common_1.SupportedDbtAdapter.POSTGRES:
+            return {
+                type: common_1.WarehouseTypes.POSTGRES,
+                host: '',
+                user: '',
+                password: '',
+                port: 5432,
+                dbname: '',
+                schema: '',
+            };
+        case common_1.SupportedDbtAdapter.DUCKDB:
+            return {
+                type: common_1.WarehouseTypes.DUCKDB,
+                database: ':memory:',
+                schema: 'main',
+                token: '',
+            };
+        case common_1.SupportedDbtAdapter.REDSHIFT:
+            return {
+                type: common_1.WarehouseTypes.REDSHIFT,
+                host: '',
+                user: '',
+                password: '',
+                port: 5432,
+                dbname: '',
+                schema: '',
+            };
+        case common_1.SupportedDbtAdapter.SNOWFLAKE:
+            return {
+                type: common_1.WarehouseTypes.SNOWFLAKE,
+                account: '',
+                user: '',
+                password: '',
+                warehouse: '',
+                database: '',
+                schema: '',
+                role: '',
+            };
+        case common_1.SupportedDbtAdapter.DATABRICKS:
+            return {
+                type: common_1.WarehouseTypes.DATABRICKS,
+                catalog: '',
+                database: '',
+                serverHostName: '',
+                httpPath: '',
+                personalAccessToken: '',
+            };
+        case common_1.SupportedDbtAdapter.TRINO:
+            return {
+                type: common_1.WarehouseTypes.TRINO,
+                host: '',
+                user: '',
+                password: '',
+                port: 5432,
+                dbname: '',
+                schema: '',
+                http_scheme: '',
+            };
+        case common_1.SupportedDbtAdapter.CLICKHOUSE:
+            return {
+                type: common_1.WarehouseTypes.CLICKHOUSE,
+                host: '',
+                user: '',
+                password: '',
+                port: 8443,
+                schema: '',
+                secure: true,
+                timeoutSeconds: 300,
+            };
+        case common_1.SupportedDbtAdapter.ATHENA:
+            return {
+                type: common_1.WarehouseTypes.ATHENA,
+                authenticationType: common_1.AthenaAuthenticationType.ACCESS_KEY,
+                region: '',
+                database: '',
+                schema: '',
+                s3StagingDir: '',
+                accessKeyId: '',
+                secretAccessKey: '',
+            };
+        default:
+            return (0, common_1.assertUnreachable)(dbtAdaptorType, `Unsupported dbt adaptor type ${dbtAdaptorType}`);
+    }
+}
+/*
+Generates a temporary Snowflake PAT to enable access on Clary which expires in 1 day.
+Snowflake PAT limitations and error messages:
+- 15 PATs per user: Exceeded maximum of 15 programmatic access tokens.
+- Must be unique: Programmatic access token CLARY_CLI already exists.
+- Can't include "-" in the name : SQL compilation error: syntax error line 1 at position 37 unexpected '-'
+*/
+const createProgramaticallySnowflakePat = async (credentials) => {
+    const tempClient = new warehouses_1.SnowflakeWarehouseClient({
+        ...credentials,
+    });
+    try {
+        console.error(`\n- Creating Snowflake Programmatic Access Token\n`);
+        const { tokenSecret, tokenName } = await tempClient.createProgrammaticAccessToken(`clary_cli_${Date.now()}`, 1);
+        console.error(`\n✓ Successfully created Snowflake PAT: ${tokenName}\n`);
+        return tokenSecret;
+    }
+    catch (e) {
+        console.error(styles.error(`\nFailed to create Snowflake PAT: ${(0, common_1.getErrorMessage)(e)}`));
+        process.exit(1);
+    }
+    return '';
+};
+exports.createProgramaticallySnowflakePat = createProgramaticallySnowflakePat;
+async function getWarehouseClient(options) {
+    let warehouseClient;
+    let credentials;
+    if (options.isDbtCloudCLI) {
+        const dbtAdaptorType = await getDbtCloudConnectionType();
+        globalState_1.default.debug(`> Using ${dbtAdaptorType} client mock`);
+        credentials = getMockCredentials(dbtAdaptorType);
+        warehouseClient = (0, warehouses_1.warehouseClientFromCredentials)({
+            ...credentials,
+            startOfWeek: (0, common_1.isWeekDay)(options.startOfWeek)
+                ? options.startOfWeek
+                : undefined,
+        });
+        const config = await (0, config_1.getConfig)();
+        // Overwrite methods that need to connect to the warehouse
+        warehouseClient.getCatalog = async (refs) => refs.reduce(async (accPromise, ref) => {
+            const acc = await accPromise; // Wait for the previous step's result
+            if (!config.context?.project) {
+                // If the project is not set(eg: on first project create), we can't fetch the schema
+                return acc;
+            }
+            try {
+                globalState_1.default.debug(`> Warehouse schema information is not available in dbt Cloud CLI. The schema ${ref.database}.${ref.schema}.${ref.table} will be fetched from the active project.`);
+                const fields = await (0, exports.getTableSchema)({
+                    projectUuid: config.context.project,
+                    tableName: ref.table,
+                    schemaName: ref.schema,
+                    databaseName: ref.database,
+                });
+                acc[ref.database] = {
+                    [ref.schema]: {
+                        [ref.table]: fields,
+                    },
+                };
+            }
+            catch (e) {
+                globalState_1.default.debug(`Failed to get schema for ${ref.database}.${ref.schema}.${ref.table}.`);
+            }
+            return acc;
+        }, Promise.resolve({}));
+        warehouseClient.streamQuery = async (_query, streamCallback) => {
+            globalState_1.default.debug(`> WarehouseClient.streamQuery() is not supported with dbt Cloud CLI. An empty result will be used.`);
+            return streamCallback({ fields: {}, rows: [] });
+        };
+        warehouseClient.runQuery = async () => {
+            globalState_1.default.debug(`> WarehouseClient.runQuery() is not supported with dbt Cloud CLI. An empty result will be used.`);
+            return { fields: {}, rows: [] };
+        };
+        warehouseClient.test = async () => {
+            globalState_1.default.debug(`> WarehouseClient.test() is not supported with dbt Cloud CLI. No test will be run.`);
+        };
+        warehouseClient.getAllTables = async () => {
+            globalState_1.default.debug(`> WarehouseClient.getAllTables() is not supported with dbt Cloud CLI. An empty result will be used.`);
+            return [];
+        };
+        warehouseClient.getFields = async () => {
+            globalState_1.default.debug(`> WarehouseClient.getFields() is not supported with dbt Cloud CLI. An empty result will be used.`);
+            return { fields: {} };
+        };
+    }
+    else {
+        const absoluteProfilesPath = path_1.default.resolve(options.profilesDir);
+        globalState_1.default.debug(`> Using profiles dir ${absoluteProfilesPath} and profile ${options.profile}`);
+        const { target } = await (0, profile_1.loadDbtTarget)({
+            profilesDir: absoluteProfilesPath,
+            profileName: options.profile,
+            targetName: options.target,
+        });
+        globalState_1.default.debug(`> Using target ${target.type}`);
+        credentials = await (0, profile_1.warehouseCredentialsFromDbtTarget)(target);
+        // Check cache before any OAuth flows to avoid repeated authentication prompts
+        const cacheKey = getWarehouseClientCacheKey(credentials);
+        if (warehouseClientCache.has(cacheKey)) {
+            globalState_1.default.debug(`> Reusing cached warehouse client (${credentials.type})`);
+            const cached = warehouseClientCache.get(cacheKey);
+            warehouseClient = cached.warehouseClient;
+            credentials = cached.credentials;
+        }
+        else {
+            // Exchange Databricks OAuth M2M credentials for access token if needed
+            if (credentials.type === common_1.WarehouseTypes.DATABRICKS &&
+                credentials.authenticationType ===
+                    common_1.DatabricksAuthenticationType.OAUTH_M2M &&
+                credentials.oauthClientId &&
+                credentials.oauthClientSecret &&
+                !credentials.token) {
+                globalState_1.default.debug(`> Exchanging Databricks OAuth credentials for access token`);
+                try {
+                    const { accessToken } = await (0, warehouses_1.exchangeDatabricksOAuthCredentials)(credentials.serverHostName, credentials.oauthClientId, credentials.oauthClientSecret);
+                    credentials.token = accessToken;
+                }
+                catch (e) {
+                    globalState_1.default.debug(`> Failed to exchange Databricks OAuth credentials for access token: ${(0, common_1.getErrorMessage)(e)}`);
+                    console.warn(styles.error(`\nFailed to authenticate with Databricks using M2M OAuth (client_id and client_secret). ` +
+                        `Perhaps you meant to use U2M OAuth instead? Set DATABRICKS_OAUTH=u2m environment variable to force U2M authentication.`));
+                    process.exit(1);
+                }
+            }
+            // Handle Databricks OAuth U2M authentication
+            if (credentials.type === common_1.WarehouseTypes.DATABRICKS &&
+                credentials.authenticationType ===
+                    common_1.DatabricksAuthenticationType.OAUTH_U2M &&
+                !credentials.token) {
+                const clientId = credentials.oauthClientId ||
+                    oauth_1.DATABRICKS_DEFAULT_OAUTH_CLIENT_ID;
+                const tokens = await (0, oauth_1.performDatabricksOAuthFlow)(credentials.serverHostName, clientId, credentials.oauthClientSecret);
+                // Store tokens in memory only
+                credentials.token = tokens.accessToken;
+                credentials.refreshToken = tokens.refreshToken;
+            }
+            globalState_1.default.debug(`> Creating new warehouse client to cache (${credentials.type})`);
+            warehouseClient = (0, warehouses_1.warehouseClientFromCredentials)({
+                ...credentials,
+                startOfWeek: (0, common_1.isWeekDay)(options.startOfWeek)
+                    ? options.startOfWeek
+                    : undefined,
+            });
+            warehouseClientCache.set(cacheKey, {
+                warehouseClient,
+                credentials,
+            });
+        }
+    }
+    return {
+        warehouseClient,
+        credentials,
+    };
+}

package/dist/handlers/dbt/refresh.d.ts

@@ -0,0 +1,11 @@
+import { Job, JobStep, Project } from '@lightdash/common';
+export declare const getProject: (projectUuid: string) => Promise<Project>;
+export declare const getRunningStepsMessage: (steps: JobStep[]) => string;
+export declare const getErrorStepsMessage: (steps: JobStep[]) => string;
+export declare const getFinalJobState: (jobUuid: string, spinnerPrefix?: string) => Promise<Job>;
+type RefreshHandlerOptions = {
+    verbose: boolean;
+};
+export declare const refreshHandler: (options: RefreshHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=refresh.d.ts.map

package/dist/handlers/dbt/refresh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refresh.d.ts","sourceRoot":"","sources":["../../../src/handlers/dbt/refresh.ts"],"names":[],"mappings":"AAAA,OAAO,EAIH,GAAG,EAEH,OAAO,EAGP,OAAO,EACV,MAAM,mBAAmB,CAAC;AAQ3B,eAAO,MAAM,UAAU,GAAU,aAAa,MAAM,qBAK9C,CAAC;AAsBP,eAAO,MAAM,sBAAsB,GAAI,OAAO,OAAO,EAAE,KAAG,MAUzD,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,EAAE,KAAG,MAUvD,CAAC;AAIF,eAAO,MAAM,gBAAgB,GACzB,SAAS,MAAM,EACf,gBAAe,MAAiC,KACjD,OAAO,CAAC,GAAG,CAcb,CAAC;AAEF,KAAK,qBAAqB,GAAG;IACzB,OAAO,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,cAAc,GAAU,SAAS,qBAAqB,kBAgElE,CAAC"}

package/dist/handlers/dbt/refresh.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshHandler = exports.getFinalJobState = exports.getErrorStepsMessage = exports.getRunningStepsMessage = exports.getProject = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+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 apiClient_1 = require("./apiClient");
+const getProject = async (projectUuid) => (0, apiClient_1.lightdashApi)({
+    method: 'GET',
+    url: `/api/v1/projects/${projectUuid}`,
+    body: undefined,
+});
+exports.getProject = getProject;
+const refreshProject = async (projectUuid) => (0, apiClient_1.lightdashApi)({
+    method: 'POST',
+    url: `/api/v1/projects/${projectUuid}/refresh`,
+    body: undefined,
+});
+const getJobState = async (jobUuid) => (0, apiClient_1.lightdashApi)({
+    method: 'GET',
+    url: `/api/v1/jobs/${jobUuid}`,
+    body: undefined,
+});
+function delay(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+const getRunningStepsMessage = (steps) => {
+    const runningStep = steps.find((step) => step.stepStatus === common_1.JobStepStatusType.RUNNING);
+    const numberOfCompletedSteps = steps.filter((step) => step.stepStatus === common_1.JobStepStatusType.DONE).length;
+    return `step ${Math.min(numberOfCompletedSteps + 1, steps.length)}/${steps.length}: ${runningStep?.stepLabel || ''}`;
+};
+exports.getRunningStepsMessage = getRunningStepsMessage;
+const getErrorStepsMessage = (steps) => {
+    const errorStep = steps.find((step) => step.stepStatus === common_1.JobStepStatusType.ERROR);
+    const numberOfCompletedSteps = steps.filter((step) => step.stepStatus === common_1.JobStepStatusType.DONE).length;
+    return `step ${Math.min(numberOfCompletedSteps + 1, steps.length)}/${steps.length}: ${errorStep?.stepLabel || ''} error ${errorStep?.stepError}`;
+};
+exports.getErrorStepsMessage = getErrorStepsMessage;
+const REFETCH_JOB_INTERVAL = 3000;
+const getFinalJobState = async (jobUuid, spinnerPrefix = 'Refreshing dbt project') => {
+    const job = await getJobState(jobUuid);
+    if (job.jobStatus === common_1.JobStatusType.DONE) {
+        return job;
+    }
+    if (job.jobStatus === common_1.JobStatusType.ERROR) {
+        throw new Error((0, exports.getErrorStepsMessage)(job.steps));
+    }
+    const spinner = globalState_1.default.getActiveSpinner();
+    spinner?.start(`  ${spinnerPrefix}, ${(0, exports.getRunningStepsMessage)(job.steps)}`);
+    return delay(REFETCH_JOB_INTERVAL).then(() => (0, exports.getFinalJobState)(jobUuid, spinnerPrefix));
+};
+exports.getFinalJobState = getFinalJobState;
+const refreshHandler = async (options) => {
+    globalState_1.default.setVerbose(options.verbose);
+    await (0, apiClient_1.checkLightdashVersion)();
+    const executionId = (0, uuid_1.v4)();
+    const config = await (0, config_1.getConfig)();
+    if (!(config.context?.project && config.context.serverUrl)) {
+        throw new common_1.AuthorizationError(`No active Clary project. Run 'clary login --help'`);
+    }
+    const projectUuid = config.context.project;
+    // Log current project info
+    globalState_1.default.logProjectInfo(config);
+    const project = await (0, exports.getProject)(projectUuid);
+    if (project.dbtConnection.type === common_1.DbtProjectType.NONE) {
+        throw new common_1.ParameterError('Clary project must be connected to a remote repository. eg: GitHub, Gitlab, etc');
+    }
+    const spinner = globalState_1.default.startSpinner(`  Refreshing dbt project`);
+    try {
+        const refreshStartTime = Date.now();
+        await analytics_1.LightdashAnalytics.track({
+            event: 'refresh.started',
+            properties: {
+                executionId,
+                projectId: projectUuid,
+            },
+        });
+        const refreshResults = await refreshProject(projectUuid);
+        await (0, exports.getFinalJobState)(refreshResults.jobUuid);
+        await analytics_1.LightdashAnalytics.track({
+            event: 'refresh.completed',
+            properties: {
+                executionId,
+                projectId: projectUuid,
+                durationMs: Date.now() - refreshStartTime,
+            },
+        });
+        spinner.stop();
+    }
+    catch (e) {
+        await analytics_1.LightdashAnalytics.track({
+            event: 'refresh.error',
+            properties: {
+                executionId,
+                projectId: projectUuid,
+                error: `Error refreshing project: ${e}`,
+            },
+        });
+        spinner.fail();
+        throw e;
+    }
+    const displayUrl = `${config.context?.serverUrl}/projects/${projectUuid}/home`;
+    console.error(`${styles.bold('Successfully refreshed project:')}`);
+    console.error('');
+    console.error(`      ${styles.bold(`⚡️ ${displayUrl}`)}`);
+    console.error('');
+};
+exports.refreshHandler = refreshHandler;

package/dist/handlers/dbt/run.d.ts

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import { DbtCompileOptions } from './compile';
+type DbtRunHandlerOptions = DbtCompileOptions & {
+    profilesDir: string;
+    projectDir: string;
+    excludeMeta: boolean;
+    verbose: boolean;
+    assumeYes: boolean;
+    assumeNo: boolean;
+    preserveColumnCase: boolean;
+};
+export declare const dbtRunHandler: (options: DbtRunHandlerOptions, command: Command) => Promise<void>;
+export {};
+//# sourceMappingURL=run.d.ts.map

package/dist/handlers/dbt/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/handlers/dbt/run.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAwB,MAAM,WAAW,CAAC;AAK1D,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAE9C,KAAK,oBAAoB,GAAG,iBAAiB,GAAG;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,kBAAkB,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF,eAAO,MAAM,aAAa,GACtB,SAAS,oBAAoB,EAC7B,SAAS,OAAO,kBAmEnB,CAAC"}

package/dist/handlers/dbt/run.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dbtRunHandler = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const commander_1 = require("commander");
+const execa_1 = tslib_1.__importDefault(require("execa"));
+const analytics_1 = require("../../analytics/analytics");
+const globalState_1 = tslib_1.__importDefault(require("../../globalState"));
+const generate_1 = require("../generate");
+const dbtRunHandler = async (options, command) => {
+    globalState_1.default.setVerbose(options.verbose);
+    if (!command.parent) {
+        throw new Error('Parent command not found');
+    }
+    if (options.assumeYes && options.assumeNo) {
+        throw new commander_1.InvalidArgumentError('Cannot use both --assume-yes and --assume-no flags');
+    }
+    const dbtStartTime = Date.now();
+    await analytics_1.LightdashAnalytics.track({
+        event: 'dbt_command.started',
+        properties: {
+            command: `${command.parent.args}`,
+        },
+    });
+    const commands = command.parent.args.reduce((acc, arg) => {
+        if (arg === '--verbose' ||
+            arg === '--assume-yes' ||
+            arg === '--assume-no')
+            return acc;
+        return [...acc, arg];
+    }, []);
+    globalState_1.default.debug(`> Running dbt command: ${commands}`);
+    try {
+        const subprocess = (0, execa_1.default)('dbt', commands, {
+            stdio: 'inherit',
+        });
+        await subprocess;
+        await analytics_1.LightdashAnalytics.track({
+            event: 'dbt_command.completed',
+            properties: {
+                command: `${commands}`,
+                durationMs: Date.now() - dbtStartTime,
+            },
+        });
+    }
+    catch (e) {
+        const msg = (0, common_1.getErrorMessage)(e);
+        await analytics_1.LightdashAnalytics.track({
+            event: 'dbt_command.error',
+            properties: {
+                command: `${commands}`,
+                error: `${msg}`,
+                durationMs: Date.now() - dbtStartTime,
+            },
+        });
+        throw new common_1.ParseError(`Failed to run dbt:\n  ${msg}`);
+    }
+    if (!options.assumeNo) {
+        await (0, generate_1.generateHandler)({
+            ...options,
+            excludeMeta: options.excludeMeta,
+            preserveColumnCase: options.preserveColumnCase,
+        });
+    }
+};
+exports.dbtRunHandler = dbtRunHandler;

package/dist/handlers/deploy.d.ts

@@ -0,0 +1,26 @@
+import { Explore, ExploreError } from '@lightdash/common';
+import { DbtCompileOptions } from './dbt/compile';
+type DeployHandlerOptions = DbtCompileOptions & {
+    projectDir: string;
+    profilesDir: string;
+    target: string | undefined;
+    profile: string | undefined;
+    create?: boolean | string;
+    verbose: boolean;
+    ignoreErrors: boolean;
+    startOfWeek?: number;
+    warehouseCredentials?: boolean;
+    organizationCredentials?: string;
+    assumeYes?: boolean;
+    useBatchedDeploy?: boolean;
+    batchSize?: string;
+    parallelBatches?: string;
+    gzip?: boolean;
+};
+type DeployArgs = DeployHandlerOptions & {
+    projectUuid: string;
+};
+export declare const deploy: (explores: (Explore | ExploreError)[], options: DeployArgs) => Promise<void>;
+export declare const deployHandler: (originalOptions: DeployHandlerOptions) => Promise<void>;
+export {};
+//# sourceMappingURL=deploy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploy.d.ts","sourceRoot":"","sources":["../../src/handlers/deploy.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,OAAO,EACP,YAAY,EASf,MAAM,mBAAmB,CAAC;AAsB3B,OAAO,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAIlD,KAAK,oBAAoB,GAAG,iBAAiB,GAAG;IAC5C,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,IAAI,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,UAAU,GAAG,oBAAoB,GAAG;IACrC,WAAW,EAAE,MAAM,CAAC;CACvB,CAAC;AA8KF,eAAO,MAAM,MAAM,GACf,UAAU,CAAC,OAAO,GAAG,YAAY,CAAC,EAAE,EACpC,SAAS,UAAU,KACpB,OAAO,CAAC,IAAI,CAuHd,CAAC;AAiGF,eAAO,MAAM,aAAa,GAAU,iBAAiB,oBAAoB,kBA+GxE,CAAC"}