@claryai/cli 0.1.0

package/dist/globalState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalState.d.ts","sourceRoot":"","sources":["../src/globalState.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,KAAK,YAAY,GAAG;IAChB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAEF,cAAM,WAAW;IACb,OAAO,CAAC,OAAO,CAAkB;IAEjC,OAAO,CAAC,cAAc,CAAkB;IAExC,OAAO,CAAC,aAAa,CAAsB;IAE3C,OAAO,CAAC,kBAAkB,CAAe;IAEzC,OAAO,CAAC,SAAS,CAAuB;;IAMxC,YAAY,IAAI,MAAM;IAOtB,iBAAiB,CAAC,KAAK,EAAE,OAAO;IAIhC,gBAAgB,IAAI,OAAO;IAI3B,gBAAgB;IAIhB,YAAY,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,OAAO,GAAG,MAAM,GAAG,GAAG,CAAC,GAAG;IAMrD,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,OAAO,EAAE;IAUlD,UAAU,CAAC,OAAO,EAAE,OAAO;IAI3B,oBAAoB,CAAC,CAAC,SAAS,MAAM,YAAY,EAC7C,MAAM,EAAE,CAAC,GACV,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS;IAI9B,gBAAgB,CAAC,CAAC,SAAS,MAAM,YAAY,EACzC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,YAAY,CAAC,CAAC,CAAC;IAK1B,iBAAiB;IAIjB,KAAK,CAAC,OAAO,EAAE,MAAM;IAMrB,cAAc,CAAC,MAAM,EAAE,MAAM;CAKhC;;AAED,wBAAiC"}

package/dist/globalState.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const ora_1 = tslib_1.__importDefault(require("ora"));
+const uuid_1 = require("uuid");
+const styles = tslib_1.__importStar(require("./styles"));
+class GlobalState {
+    verbose = false;
+    nonInteractive = false;
+    activeSpinner;
+    savedPromptAnswers;
+    sessionId = null;
+    constructor() {
+        this.savedPromptAnswers = {};
+    }
+    getSessionId() {
+        if (!this.sessionId) {
+            this.sessionId = (0, uuid_1.v4)();
+        }
+        return this.sessionId;
+    }
+    setNonInteractive(value) {
+        this.nonInteractive = value;
+    }
+    isNonInteractive() {
+        return this.nonInteractive || process.env.CI === 'true';
+    }
+    getActiveSpinner() {
+        return this.activeSpinner;
+    }
+    startSpinner(options) {
+        this.activeSpinner = (0, ora_1.default)(options);
+        this.activeSpinner.start();
+        return this.activeSpinner;
+    }
+    log(message, ...optionalParams) {
+        const spinner = this.getActiveSpinner();
+        const shouldRestartSpinner = spinner?.isSpinning;
+        spinner?.stop();
+        console.error(message, ...optionalParams);
+        if (shouldRestartSpinner) {
+            spinner?.start();
+        }
+    }
+    setVerbose(verbose) {
+        this.verbose = verbose;
+    }
+    getSavedPromptAnswer(prompt) {
+        return this.savedPromptAnswers[prompt];
+    }
+    savePromptAnswer(prompt, value) {
+        this.savedPromptAnswers[prompt] = value;
+    }
+    clearPromptAnswer() {
+        this.savedPromptAnswers = {};
+    }
+    debug(message) {
+        if (this.verbose) {
+            this.log(styles.debug(message));
+        }
+    }
+    logProjectInfo(config) {
+        const projectUuid = config.context?.project;
+        this.log(`\n${styles.success('Using project:')} ${projectUuid}\n`);
+    }
+}
+exports.default = new GlobalState();

package/dist/handlers/asyncQuery.d.ts

@@ -0,0 +1,7 @@
+import { ApiGetAsyncQueryResults, ResultRow } from '@lightdash/common';
+export declare function pollForResults(projectUuid: string, queryUuid: string, options?: {
+    pageSize?: number;
+    backoffMs?: number;
+}): Promise<ApiGetAsyncQueryResults>;
+export declare function resultsToCsv(columns: string[], rows: ResultRow[]): string;
+//# sourceMappingURL=asyncQuery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"asyncQuery.d.ts","sourceRoot":"","sources":["../../src/handlers/asyncQuery.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EAEvB,SAAS,EACZ,MAAM,mBAAmB,CAAC;AAa3B,wBAAsB,cAAc,CAChC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GACxD,OAAO,CAAC,uBAAuB,CAAC,CAwBlC;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,MAAM,CAkBzE"}

package/dist/handlers/asyncQuery.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollForResults = pollForResults;
+exports.resultsToCsv = resultsToCsv;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const apiClient_1 = require("./dbt/apiClient");
+const INITIAL_BACKOFF_MS = 250;
+const MAX_BACKOFF_MS = 1000;
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function pollForResults(projectUuid, queryUuid, options = {}) {
+    const { pageSize, backoffMs = INITIAL_BACKOFF_MS } = options;
+    const pageSizeParam = pageSize ? `?pageSize=${pageSize}` : '';
+    const result = await (0, apiClient_1.lightdashApi)({
+        method: 'GET',
+        url: `/api/v2/projects/${projectUuid}/query/${queryUuid}${pageSizeParam}`,
+        body: undefined,
+    });
+    globalState_1.default.debug(`> Query status: ${result.status}`);
+    if (result.status === common_1.QueryHistoryStatus.PENDING ||
+        result.status === common_1.QueryHistoryStatus.QUEUED ||
+        result.status === common_1.QueryHistoryStatus.EXECUTING) {
+        await sleep(backoffMs);
+        return pollForResults(projectUuid, queryUuid, {
+            pageSize,
+            backoffMs: Math.min(backoffMs * 2, MAX_BACKOFF_MS),
+        });
+    }
+    return result;
+}
+function resultsToCsv(columns, rows) {
+    const escapeValue = (value) => {
+        if (value === null || value === undefined) {
+            return '';
+        }
+        const str = String(value);
+        if (str.includes(',') || str.includes('"') || str.includes('\n')) {
+            return `"${str.replace(/"/g, '""')}"`;
+        }
+        return str;
+    };
+    const header = columns.map(escapeValue).join(',');
+    const dataRows = rows.map((row) => columns.map((col) => escapeValue(row[col]?.value?.raw)).join(','));
+    return [header, ...dataRows].join('\n');
+}

package/dist/handlers/compile.d.ts

@@ -0,0 +1,16 @@
+import { Explore, ExploreError } from '@lightdash/common';
+import { DbtCompileOptions } from './dbt/compile';
+export type CompileHandlerOptions = DbtCompileOptions & {
+    projectDir: string;
+    profilesDir: string;
+    target: string | undefined;
+    profile: string | undefined;
+    vars: string | undefined;
+    verbose: boolean;
+    startOfWeek?: number;
+    warehouseCredentials?: boolean;
+    disableTimestampConversion?: boolean;
+};
+export declare const compile: (options: CompileHandlerOptions) => Promise<(Explore | ExploreError)[]>;
+export declare const compileHandler: (originalOptions: CompileHandlerOptions) => Promise<void>;
+//# sourceMappingURL=compile.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../../src/handlers/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAOH,OAAO,EACP,YAAY,EAYf,MAAM,mBAAmB,CAAC;AAa3B,OAAO,EAAE,iBAAiB,EAA8B,MAAM,eAAe,CAAC;AAI9E,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,GAAG;IACpD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,0BAA0B,CAAC,EAAE,OAAO,CAAC;CACxC,CAAC;AAwHF,eAAO,MAAM,OAAO,GAAU,SAAS,qBAAqB,wCAmP3D,CAAC;AAEF,eAAO,MAAM,cAAc,GACvB,iBAAiB,qBAAqB,kBAmCzC,CAAC"}

package/dist/handlers/compile.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileHandler = exports.compile = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@lightdash/common");
+const warehouses_1 = require("@lightdash/warehouses");
+const path_1 = tslib_1.__importDefault(require("path"));
+const uuid_1 = require("uuid");
+const analytics_1 = require("../analytics/analytics");
+const context_1 = require("../dbt/context");
+const manifest_1 = require("../dbt/manifest");
+const validation_1 = require("../dbt/validation");
+const globalState_1 = tslib_1.__importDefault(require("../globalState"));
+const lightdash_config_1 = require("../lightdash-config");
+const loader_1 = require("../lightdash/loader");
+const projectType_1 = require("../lightdash/projectType");
+const styles = tslib_1.__importStar(require("../styles"));
+const compile_1 = require("./dbt/compile");
+const getDbtVersion_1 = require("./dbt/getDbtVersion");
+const getWarehouseClient_1 = tslib_1.__importDefault(require("./dbt/getWarehouseClient"));
+const getExploresFromLightdashYmlProject = async (projectDir, lightdashProjectConfig, startOfWeek, disableTimestampConversion) => {
+    // Try to load Lightdash YAML models
+    const lightdashModels = await (0, loader_1.loadLightdashModels)(projectDir);
+    if (lightdashModels.length === 0) {
+        return null; // No Lightdash models, use dbt path
+    }
+    globalState_1.default.debug(`> Found ${lightdashModels.length} Lightdash YAML models`);
+    if (!lightdashProjectConfig.warehouse?.type) {
+        throw new common_1.ParseError('Lightdash models found but no warehouse type specified in lightdash.config.yml.\n' +
+            'Add a warehouse section:\n' +
+            'warehouse:\n' +
+            '  type: postgres  # or bigquery, snowflake, redshift, databricks, trino, clickhouse');
+    }
+    const adapterType = lightdashProjectConfig.warehouse.type;
+    globalState_1.default.debug(`> Using adapter type from lightdash.config.yml: ${adapterType}`);
+    // Convert Lightdash models to DbtModelNode format
+    const validModels = (0, common_1.convertLightdashModelsToDbtModels)(lightdashModels);
+    if (validModels.length === 0) {
+        return null;
+    }
+    globalState_1.default.debug('> Skipping warehouse catalog (types in YAML)');
+    const warehouseSqlBuilder = (0, warehouses_1.warehouseSqlBuilderFromType)(adapterType, startOfWeek);
+    const validExplores = await (0, common_1.convertExplores)(validModels, false, warehouseSqlBuilder.getAdapterType(), [], warehouseSqlBuilder, lightdashProjectConfig, {
+        disableTimestampConversion,
+        allowPartialCompilation: process.env.PARTIAL_COMPILATION_ENABLED !== 'false',
+        postProcessors: [common_1.preAggregatePostProcessor],
+    });
+    return validExplores;
+};
+/**
+ * When using --defer, non-selected models pulled in via joins
+ * have incorrect schema/relation_name (they point to the dev target
+ * instead of production). Return new models with production values
+ * from the state manifest.
+ */
+async function patchDeferredModels(compiledModels, originallySelectedModelIds, state) {
+    const statePath = path_1.default.resolve(state);
+    globalState_1.default.debug(`> Loading state manifest for defer from ${statePath}`);
+    try {
+        const stateManifest = await (0, manifest_1.loadManifest)({
+            targetDir: statePath,
+        });
+        const stateModels = (0, common_1.getModelsFromManifest)(stateManifest);
+        const stateModelMap = new Map(stateModels.map((m) => [m.unique_id, m]));
+        const patchedModels = compiledModels.map((model) => {
+            if (originallySelectedModelIds.includes(model.unique_id)) {
+                return model;
+            }
+            const stateModel = stateModelMap.get(model.unique_id);
+            if (!stateModel) {
+                return model;
+            }
+            globalState_1.default.debug(`> Deferred model ${model.name}: using production schema ${stateModel.schema}`);
+            return {
+                ...model,
+                relation_name: stateModel.relation_name,
+                schema: stateModel.schema,
+                database: stateModel.database,
+            };
+        });
+        const patchedCount = patchedModels.filter((m, i) => m !== compiledModels[i]).length;
+        if (patchedCount > 0) {
+            globalState_1.default.debug(`> Patched ${patchedCount} deferred model(s) with production schema`);
+        }
+        return patchedModels;
+    }
+    catch (e) {
+        globalState_1.default.debug(`> Warning: Could not load state manifest for defer patching: ${(0, common_1.getErrorMessage)(e)}`);
+        return compiledModels;
+    }
+}
+const compile = async (options) => {
+    const dbtVersionResult = await (0, getDbtVersion_1.tryGetDbtVersion)();
+    const executionId = (0, uuid_1.v4)();
+    const startTime = Date.now();
+    await analytics_1.LightdashAnalytics.track({
+        event: 'compile.started',
+        properties: {
+            executionId,
+            dbtVersion: dbtVersionResult.success
+                ? dbtVersionResult.version.verboseVersion
+                : undefined,
+            useDbtList: !!options.useDbtList,
+            skipWarehouseCatalog: !!options.skipWarehouseCatalog,
+            skipDbtCompile: !!options.skipDbtCompile,
+        },
+    });
+    const absoluteProjectPath = path_1.default.resolve(options.projectDir);
+    globalState_1.default.debug(`> Compiling with project dir ${absoluteProjectPath}`);
+    const lightdashProjectConfig = await (0, lightdash_config_1.readAndLoadLightdashProjectConfig)(absoluteProjectPath);
+    globalState_1.default.debug(`> Loaded Clary project config`);
+    // Try Clary project compile
+    let explores = null;
+    let dbtMetrics = null;
+    explores = await getExploresFromLightdashYmlProject(absoluteProjectPath, lightdashProjectConfig, options.startOfWeek, options.disableTimestampConversion);
+    // Load dbt Project
+    if (explores === null) {
+        if (!dbtVersionResult.success) {
+            await analytics_1.LightdashAnalytics.track({
+                event: 'compile.error',
+                properties: {
+                    executionId,
+                    error: 'dbt not found',
+                },
+            });
+            throw dbtVersionResult.error;
+        }
+        const context = await (0, context_1.getDbtContext)({
+            projectDir: absoluteProjectPath,
+            targetPath: options.targetPath,
+        });
+        const { compiledModelIds, originallySelectedModelIds } = await (0, compile_1.maybeCompileModelsAndJoins)({ targetDir: context.targetDir }, options);
+        const manifest = await (0, manifest_1.loadManifest)({ targetDir: context.targetDir });
+        const manifestVersion = (0, common_1.getDbtManifestVersion)(manifest);
+        const manifestModels = (0, common_1.getModelsFromManifest)(manifest);
+        const compiledModels = (0, common_1.getCompiledModels)(manifestModels, compiledModelIds);
+        // When using --defer, non-selected models pulled in via joins
+        // have incorrect schema/relation_name (they point to the dev target
+        // instead of production). Patch them from the state manifest.
+        const modelsForValidation = options.defer && options.state && originallySelectedModelIds
+            ? await patchDeferredModels(compiledModels, originallySelectedModelIds, options.state)
+            : compiledModels;
+        const adapterType = manifest.metadata.adapter_type;
+        const { valid: validModels, invalid: failedExplores } = await (0, validation_1.validateDbtModel)(adapterType, manifestVersion, modelsForValidation);
+        if (failedExplores.length > 0) {
+            const errors = failedExplores.map((failedExplore) => failedExplore.errors.map((error) => `- ${failedExplore.name}: ${error.message}\n`));
+            console.error(styles.warning(`Found ${failedExplores.length} errors when validating dbt models:
+    ${errors.join('')}`));
+        }
+        // Skipping assumes yml has the field types.
+        let catalog = {};
+        if (!options.skipWarehouseCatalog) {
+            const { warehouseClient } = await (0, getWarehouseClient_1.default)({
+                isDbtCloudCLI: dbtVersionResult.success
+                    ? dbtVersionResult.version.isDbtCloudCLI
+                    : false,
+                profilesDir: options.profilesDir,
+                profile: options.profile || context.profileName,
+                target: options.target,
+                startOfWeek: options.startOfWeek,
+            });
+            globalState_1.default.debug('> Fetching warehouse catalog');
+            catalog = await warehouseClient.getCatalog((0, common_1.getSchemaStructureFromDbtModels)(validModels));
+        }
+        else {
+            globalState_1.default.debug('> Skipping warehouse catalog');
+        }
+        const validModelsWithTypes = (0, common_1.attachTypesToModels)(validModels, catalog, false);
+        if (!(0, common_1.isSupportedDbtAdapter)(manifest.metadata)) {
+            await analytics_1.LightdashAnalytics.track({
+                event: 'compile.error',
+                properties: {
+                    executionId,
+                    dbtVersion: dbtVersionResult.success
+                        ? dbtVersionResult.version.verboseVersion
+                        : undefined,
+                    error: `Dbt adapter ${manifest.metadata.adapter_type} is not supported`,
+                },
+            });
+            throw new common_1.ParseError(`Dbt adapter ${manifest.metadata.adapter_type} is not supported`);
+        }
+        globalState_1.default.debug(`> Converting explores with adapter: ${manifest.metadata.adapter_type}`);
+        globalState_1.default.debug(`> Loading Clary project config from ${absoluteProjectPath}`);
+        const warehouseSqlBuilder = (0, warehouses_1.warehouseSqlBuilderFromType)(adapterType, options.startOfWeek);
+        const validExplores = await (0, common_1.convertExplores)(validModelsWithTypes, false, manifest.metadata.adapter_type, [
+            common_1.DbtManifestVersion.V10,
+            common_1.DbtManifestVersion.V11,
+            common_1.DbtManifestVersion.V12,
+        ].includes(manifestVersion)
+            ? []
+            : Object.values(manifest.metrics || {}), warehouseSqlBuilder, lightdashProjectConfig, {
+            disableTimestampConversion: options.disableTimestampConversion,
+            allowPartialCompilation: process.env.PARTIAL_COMPILATION_ENABLED !== 'false',
+            postProcessors: [common_1.preAggregatePostProcessor],
+        });
+        console.error('');
+        explores = [...validExplores, ...failedExplores];
+        dbtMetrics = manifest.metrics;
+    }
+    let errors = 0;
+    let partialSuccess = 0;
+    let success = 0;
+    explores.forEach((e) => {
+        let status;
+        let messages = '';
+        if ((0, common_1.isExploreError)(e)) {
+            status = styles.error('ERROR');
+            messages = `: ${styles.error(e.errors.map((err) => err.message).join(', '))}`;
+            errors += 1;
+        }
+        else if (process.env.PARTIAL_COMPILATION_ENABLED !== 'false' &&
+            'warnings' in e &&
+            e.warnings &&
+            e.warnings.length > 0) {
+            status = styles.warning('PARTIAL_SUCCESS');
+            messages = `: ${styles.warning(e.warnings.map((warning) => warning.message).join(', '))}`;
+            partialSuccess += 1;
+        }
+        else {
+            status = styles.success('SUCCESS');
+            success += 1;
+        }
+        console.error(`- ${status}> ${e.name} ${messages}`);
+    });
+    console.error('');
+    if (process.env.PARTIAL_COMPILATION_ENABLED !== 'false' &&
+        partialSuccess > 0) {
+        console.error(`Compiled ${explores.length} explores, SUCCESS=${success} PARTIAL_SUCCESS=${partialSuccess} ERRORS=${errors}`);
+    }
+    else {
+        console.error(`Compiled ${explores.length} explores, SUCCESS=${success} ERRORS=${errors}`);
+    }
+    const metricsCount = dbtMetrics === null ? 0 : Object.values(dbtMetrics).length;
+    await analytics_1.LightdashAnalytics.track({
+        event: 'compile.completed',
+        properties: {
+            executionId,
+            explores: explores.length,
+            errors,
+            dbtMetrics: metricsCount,
+            dbtVersion: dbtVersionResult.success
+                ? dbtVersionResult.version.verboseVersion
+                : undefined,
+            durationMs: Date.now() - startTime,
+        },
+    });
+    return explores;
+};
+exports.compile = compile;
+const compileHandler = async (originalOptions) => {
+    const options = { ...originalOptions };
+    // Detect project type and configure options accordingly
+    const projectTypeConfig = await (0, projectType_1.detectProjectType)({
+        projectDir: options.projectDir,
+        userOptions: {
+            warehouseCredentials: options.warehouseCredentials,
+            skipDbtCompile: options.skipDbtCompile,
+            skipWarehouseCatalog: options.skipWarehouseCatalog,
+        },
+    });
+    // Apply project type configuration to options
+    options.warehouseCredentials = projectTypeConfig.warehouseCredentials;
+    options.skipDbtCompile = projectTypeConfig.skipDbtCompile;
+    options.skipWarehouseCatalog = projectTypeConfig.skipWarehouseCatalog;
+    globalState_1.default.setVerbose(options.verbose);
+    const explores = await (0, exports.compile)(options);
+    const errorsCount = explores.filter((e) => (0, common_1.isExploreError)(e)).length;
+    console.error('');
+    if (errorsCount > 0) {
+        console.error(styles.error(`Failed to compile project. Found ${errorsCount} error${errorsCount > 1 ? 's' : ''}`));
+        process.exit(1);
+    }
+    else {
+        console.error(styles.success('Successfully compiled project'));
+    }
+};
+exports.compileHandler = compileHandler;

package/dist/handlers/compile.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=compile.test.d.ts.map

package/dist/handlers/compile.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.test.d.ts","sourceRoot":"","sources":["../../src/handlers/compile.test.ts"],"names":[],"mappings":""}

package/dist/handlers/compile.test.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const os = tslib_1.__importStar(require("os"));
+const path = tslib_1.__importStar(require("path"));
+const styles = tslib_1.__importStar(require("../styles"));
+const compile_1 = require("./compile");
+jest.mock('execa');
+jest.mock('../analytics/analytics');
+jest.mock('../config', () => ({
+    getConfig: jest.fn().mockResolvedValue({ user: null, context: null }),
+}));
+describe('compile', () => {
+    let tempDir;
+    beforeEach(async () => {
+        jest.clearAllMocks();
+        tempDir = await promises_1.default.mkdtemp(path.join(os.tmpdir(), 'lightdash-compile-test-'));
+        // Create minimal lightdash.config.yml
+        await promises_1.default.writeFile(path.join(tempDir, 'lightdash.config.yml'), `
+warehouse:
+  type: postgres
+            `);
+        // Create lightdash/models directory and a test model
+        const modelsDir = path.join(tempDir, 'lightdash', 'models');
+        await promises_1.default.mkdir(modelsDir, { recursive: true });
+        await promises_1.default.writeFile(path.join(modelsDir, 'test_model.yml'), `
+version: 1
+type: model
+name: test_model
+description: Test model
+sql_from: "SELECT * FROM test_table"
+dimensions:
+  - name: id
+    description: ID column
+    type: number
+    sql: id
+            `);
+    });
+    afterEach(async () => {
+        await promises_1.default.rm(tempDir, { recursive: true, force: true });
+    });
+    test('should compile Lightdash YAML project without dbt installed', async () => {
+        // Mock analytics to prevent actual tracking
+        const { LightdashAnalytics } = await Promise.resolve().then(() => tslib_1.__importStar(require('../analytics/analytics')));
+        LightdashAnalytics.track.mockResolvedValue(undefined);
+        const result = await (0, compile_1.compile)({
+            projectDir: tempDir,
+            profilesDir: '',
+            target: undefined,
+            profile: undefined,
+            vars: undefined,
+            verbose: false,
+            startOfWeek: 0,
+            skipWarehouseCatalog: true,
+            skipDbtCompile: true,
+            useDbtList: false,
+            select: undefined,
+            models: undefined,
+            threads: undefined,
+            noVersionCheck: false,
+            exclude: undefined,
+            selector: undefined,
+            state: undefined,
+            fullRefresh: false,
+            defer: false,
+            targetPath: undefined,
+            favorState: false,
+            warehouseCredentials: false,
+            disableTimestampConversion: false,
+        });
+        // Should succeed even though dbt is not installed
+        expect(result).toBeDefined();
+        expect(result.length).toBeGreaterThan(0);
+        // Analytics should be called even though dbt is not found
+        const trackCalls = LightdashAnalytics.track.mock.calls;
+        expect(LightdashAnalytics.track).toHaveBeenCalledWith(expect.objectContaining({
+            event: 'compile.started',
+            properties: expect.objectContaining({
+                dbtVersion: undefined,
+            }),
+        }));
+        expect(LightdashAnalytics.track).toHaveBeenCalledWith(expect.objectContaining({
+            event: 'compile.completed',
+        }));
+        // Verify compile.started was called with undefined dbtVersion
+        const startedCall = trackCalls.find((call) => call[0].event === 'compile.started');
+        expect(startedCall).toBeDefined();
+        expect(startedCall[0].properties.dbtVersion).toBeUndefined();
+    });
+    test('should display PARTIAL_SUCCESS with warning messages', () => {
+        // Mock console.error to capture output
+        const consoleSpy = jest.spyOn(console, 'error').mockImplementation();
+        // Partial compilation is now enabled by default
+        const originalEnv = process.env.PARTIAL_COMPILATION_ENABLED;
+        // No need to set to 'true' as it's enabled by default
+        try {
+            // Create mock explores array with different statuses
+            const mockExplores = [
+                {
+                    name: 'successful_explore',
+                    label: 'Successful Explore',
+                    tags: [],
+                    baseTable: 'table1',
+                    // No warnings or errors - should be SUCCESS
+                },
+                {
+                    name: 'explore_with_warnings',
+                    label: 'Explore with Warnings',
+                    tags: [],
+                    baseTable: 'table2',
+                    warnings: [
+                        {
+                            type: 'MISSING_TABLE',
+                            message: 'Join to table "missing_table" was skipped',
+                        },
+                        {
+                            type: 'FIELD_ERROR',
+                            message: 'Field compilation warning',
+                        },
+                    ],
+                },
+                {
+                    name: 'failed_explore',
+                    label: 'Failed Explore',
+                    tags: [],
+                    errors: [
+                        {
+                            type: 'NO_DIMENSIONS_FOUND',
+                            message: 'No dimensions found in model',
+                        },
+                    ],
+                },
+            ];
+            // Simulate the explore display logic from compile.ts
+            let errors = 0;
+            let partialSuccess = 0;
+            let success = 0;
+            mockExplores.forEach((e) => {
+                let status;
+                let messages = '';
+                if ('errors' in e && e.errors) {
+                    status = styles.error('ERROR');
+                    messages = `: ${styles.error(e.errors.map((err) => err.message).join(', '))}`;
+                    errors += 1;
+                }
+                else if (process.env.PARTIAL_COMPILATION_ENABLED !== 'false' &&
+                    'warnings' in e &&
+                    e.warnings &&
+                    e.warnings.length > 0) {
+                    status = styles.warning('PARTIAL_SUCCESS');
+                    messages = `: ${styles.warning(e.warnings
+                        .map((warning) => warning.message)
+                        .join(', '))}`;
+                    partialSuccess += 1;
+                }
+                else {
+                    status = styles.success('SUCCESS');
+                    success += 1;
+                }
+                console.error(`- ${status}> ${e.name} ${messages}`);
+            });
+            console.error('');
+            // Display summary
+            if (process.env.PARTIAL_COMPILATION_ENABLED !== 'false' &&
+                partialSuccess > 0) {
+                console.error(`Compiled ${mockExplores.length} explores, SUCCESS=${success} PARTIAL_SUCCESS=${partialSuccess} ERRORS=${errors}`);
+            }
+            else {
+                console.error(`Compiled ${mockExplores.length} explores, SUCCESS=${success} ERRORS=${errors}`);
+            }
+            // Verify the output
+            const calls = consoleSpy.mock.calls.map((call) => call[0]);
+            // Check that PARTIAL_SUCCESS status is displayed
+            const partialSuccessCall = calls.find((call) => typeof call === 'string' &&
+                call.includes('PARTIAL_SUCCESS> explore_with_warnings'));
+            expect(partialSuccessCall).toBeDefined();
+            expect(partialSuccessCall).toContain('Join to table "missing_table" was skipped');
+            expect(partialSuccessCall).toContain('Field compilation warning');
+            // Check that SUCCESS status is displayed
+            const successCall = calls.find((call) => typeof call === 'string' &&
+                call.includes('SUCCESS> successful_explore'));
+            expect(successCall).toBeDefined();
+            // Check that ERROR status is displayed
+            const errorCall = calls.find((call) => typeof call === 'string' &&
+                call.includes('ERROR> failed_explore'));
+            expect(errorCall).toBeDefined();
+            // Check the summary includes PARTIAL_SUCCESS count
+            const summaryCall = calls.find((call) => typeof call === 'string' &&
+                call.includes('Compiled') &&
+                call.includes('PARTIAL_SUCCESS='));
+            expect(summaryCall).toBeDefined();
+            expect(summaryCall).toContain('SUCCESS=1 PARTIAL_SUCCESS=1 ERRORS=1');
+        }
+        finally {
+            // Clean up
+            consoleSpy.mockRestore();
+            process.env.PARTIAL_COMPILATION_ENABLED = originalEnv;
+        }
+    });
+});