@lightdash/cli 2.228.0 → 2.229.0

package/dist/handlers/apps/validate.test.js

@@ -1,526 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const common_1 = require("@lightdash/common");
-const fs_1 = require("fs");
-const os = tslib_1.__importStar(require("os"));
-const path = tslib_1.__importStar(require("path"));
-const appCodeFiles_1 = require("./appCodeFiles");
-const validate_1 = require("./validate");
-const semanticLayer = [
-    'models:',
-    '  - name: orders',
-    '    meta:',
-    '      metrics:',
-    '        total_revenue:',
-    '          type: sum',
-    '    columns:',
-    '      - name: status',
-].join('\n');
-const defaultManifest = {
-    codeVersion: 1,
-    projectUuid: 'project-uuid',
-    slug: 'orders-app',
-    version: 1,
-    name: 'Orders app',
-    description: '',
-    template: null,
-    downloadedAt: '2026-08-01T00:00:00.000Z',
-    externalConnections: [{ alias: 'stripe', connectionSlug: 'stripe-api' }],
-};
-const validSource = `
-    import { query } from '@lightdash/query-sdk';
-    query('orders').dimensions(['status']).metrics(['total_revenue']);
-    lightdash.externalFetch('stripe', { path: '/charges' });
-`;
-const makeApp = async (args) => {
-    const dir = await fs_1.promises.mkdtemp(path.join(os.tmpdir(), 'ld-app-validate-'));
-    const code = {
-        manifest: args?.manifest ?? defaultManifest,
-        files: [
-            {
-                path: 'src/App.tsx',
-                contentBase64: Buffer.from(args?.source ?? validSource).toString('base64'),
-            },
-        ],
-    };
-    await (0, appCodeFiles_1.writeBundleToDir)(dir, code);
-    const layout = args?.semanticLayout ?? 'sharded';
-    if (layout === 'legacy') {
-        const contextDir = path.join(dir, '.lightdash', 'context');
-        await fs_1.promises.mkdir(contextDir, { recursive: true });
-        await fs_1.promises.writeFile(path.join(contextDir, 'semantic-layer.yml'), semanticLayer);
-    }
-    else if (layout === 'sharded') {
-        const modelsDir = path.join(dir, '.lightdash', 'context', 'models');
-        await fs_1.promises.mkdir(modelsDir, { recursive: true });
-        await Promise.all([
-            fs_1.promises.writeFile(path.join(dir, '.lightdash', 'context', 'semantic-layer.yml'), '# See models/'),
-            fs_1.promises.writeFile(path.join(modelsDir, 'orders.yml'), semanticLayer),
-        ]);
-    }
-    if (args?.packageJson !== undefined) {
-        await fs_1.promises.writeFile(path.join(dir, 'package.json'), args.packageJson);
-    }
-    if (args?.lockfile !== undefined) {
-        await fs_1.promises.writeFile(path.join(dir, 'pnpm-lock.yaml'), args.lockfile);
-    }
-    return dir;
-};
-const unusedLiveLoader = () => {
-    throw new Error('live semantic layer should not be loaded');
-};
-const liveIndex = (0, common_1.buildDataAppExploreIndexFromModelFiles)([
-    { path: 'orders.yml', content: semanticLayer },
-]);
-describe('validateLocalDataApp', () => {
-    it.each(['sharded', 'legacy'])('validates a correct app against a %s offline semantic layer', async (semanticLayout) => {
-        const dir = await makeApp({ semanticLayout });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(true);
-        expect(result.errors).toEqual([]);
-        expect(result.coverage).toMatchObject({
-            callSites: 2,
-            fullyResolved: 2,
-            unanalyzed: 0,
-        });
-    });
-    it('reports semantic errors and undeclared externalFetch aliases with source locations', async () => {
-        const dir = await makeApp({
-            source: `
-                import { query } from '@lightdash/query-sdk';
-                query('ordrs').dimensions(['missing_field']);
-                client.externalFetch('salesforce', { path: '/accounts' });
-            `,
-        });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(false);
-        expect(result.errors).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                code: 'semantic_reference',
-                message: "Explore 'ordrs' does not exist — did you mean 'orders'?",
-                location: expect.objectContaining({ path: 'src/App.tsx' }),
-            }),
-            expect.objectContaining({
-                code: 'external_connection',
-                message: expect.stringContaining('salesforce'),
-                location: expect.objectContaining({ path: 'src/App.tsx' }),
-            }),
-        ]));
-    });
-    it('counts dynamic query call sites as unanalyzed without failing', async () => {
-        const dir = await makeApp({
-            source: `
-                import { query } from '@lightdash/query-sdk';
-                function build(explore) {
-                    return query(explore).dimensions(['status']);
-                }
-            `,
-        });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(true);
-        expect(result.coverage).toMatchObject({
-            callSites: 1,
-            unresolved: 1,
-            unanalyzed: 1,
-        });
-    });
-    it('does not treat a dynamic externalFetch alias as an error', async () => {
-        const dir = await makeApp({
-            source: `
-                function load(client, alias) {
-                    return client.externalFetch(alias, { path: '/resource' });
-                }
-            `,
-            semanticLayout: 'none',
-        });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(true);
-        expect(result.errors).toEqual([]);
-        expect(result.coverage).toMatchObject({
-            callSites: 1,
-            unresolved: 1,
-            unanalyzed: 1,
-        });
-    });
-    it('uses the live semantic layer and does not require a local snapshot', async () => {
-        const dir = await makeApp({ semanticLayout: 'none' });
-        const loadLiveIndex = vi.fn().mockResolvedValue(liveIndex);
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: true,
-            liveProjectUuid: 'configured-project-uuid',
-            loadLiveIndex,
-        });
-        expect(result.valid).toBe(true);
-        expect(result.projectUuid).toBe('configured-project-uuid');
-        expect(loadLiveIndex).toHaveBeenCalledWith('configured-project-uuid');
-    });
-    it('explains how to configure a project for live validation', async () => {
-        const dir = await makeApp({ semanticLayout: 'none' });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: true,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(false);
-        expect(result.projectUuid).toBeNull();
-        expect(result.errors).toContainEqual(expect.objectContaining({
-            code: 'semantic_layer',
-            message: expect.stringContaining('lightdash config set-project'),
-        }));
-    });
-    it('gives an upgrade path instead of crashing on a missing offline snapshot', async () => {
-        const dir = await makeApp({ semanticLayout: 'none' });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(false);
-        expect(result.errors).toContainEqual(expect.objectContaining({
-            code: 'semantic_layer',
-            message: expect.stringContaining('Re-download the app'),
-        }));
-    });
-    it('validates slug and vizSchema from the manifest', async () => {
-        const manifest = {
-            ...defaultManifest,
-            slug: '../invalid',
-            vizSchema: { fields: 'not-an-array' },
-        };
-        const dir = await makeApp({ manifest });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.errors).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                code: 'manifest',
-                message: expect.stringContaining('Invalid slug'),
-            }),
-            expect.objectContaining({
-                code: 'manifest',
-                message: expect.stringContaining('Invalid vizSchema'),
-            }),
-        ]));
-    });
-    it('validates the icon from the manifest', async () => {
-        const manifest = {
-            ...defaultManifest,
-            icon: 'not-a-real-icon',
-        };
-        const dir = await makeApp({ manifest });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.errors).toContainEqual(expect.objectContaining({
-            code: 'manifest',
-            message: expect.stringContaining('Invalid icon'),
-        }));
-    });
-    it.each([null, 'chart-sankey'])('accepts icon %s', async (icon) => {
-        const manifest = { ...defaultManifest, icon };
-        const dir = await makeApp({ manifest });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.errors).not.toContainEqual(expect.objectContaining({ code: 'manifest' }));
-    });
-    it('requires a pnpm lockfile for custom dependencies', async () => {
-        const dir = await makeApp({
-            packageJson: JSON.stringify({
-                dependencies: { 'left-pad': '1.3.0' },
-            }),
-        });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.errors).toContainEqual(expect.objectContaining({
-            code: 'dependencies',
-            message: expect.stringContaining('pnpm-lock.yaml'),
-        }));
-    });
-    it('surfaces parser failures as warnings rather than errors', async () => {
-        const dir = await makeApp({
-            source: 'const broken = ;',
-            semanticLayout: 'none',
-        });
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-        });
-        expect(result.valid).toBe(true);
-        expect(result.warnings).toContainEqual(expect.objectContaining({ code: 'source_parse' }));
-    });
-    it('includes Cloud-parity build failures when --build is enabled', async () => {
-        const dir = await makeApp();
-        const runBuild = vi.fn().mockResolvedValue([
-            {
-                code: 'build',
-                message: 'Vite build failed: broken import',
-                location: null,
-            },
-        ]);
-        const result = await (0, validate_1.validateLocalDataApp)(dir, {
-            build: true,
-            live: false,
-            loadLiveIndex: unusedLiveLoader,
-            runBuild,
-        });
-        expect(runBuild).toHaveBeenCalledOnce();
-        expect(result.valid).toBe(false);
-        expect(result.errors).toContainEqual(expect.objectContaining({
-            code: 'build',
-            message: expect.stringContaining('broken import'),
-        }));
-    });
-});
-describe('validateDataAppBuild', () => {
-    it('builds source in an isolated vendored scaffold with bare Vite', async () => {
-        const dir = await makeApp();
-        await fs_1.promises.mkdir(path.join(dir, 'node_modules'));
-        const bundle = await (0, appCodeFiles_1.readBundleFromDir)(dir);
-        const runCommand = vi.fn(async (command) => {
-            expect(command).toMatchObject({
-                command: 'vite',
-                args: ['build'],
-                preferLocal: true,
-                timeoutMs: 60_000,
-            });
-            expect(command.args).not.toContain('tsc');
-            await expect(fs_1.promises.readFile(path.join(command.cwd, 'vite.config.js'), 'utf-8')).resolves.toContain('defineConfig');
-            await expect(fs_1.promises.readFile(path.join(command.cwd, 'src', 'App.tsx'), 'utf-8')).resolves.toContain("query('orders')");
-            expect((await fs_1.promises.lstat(path.join(command.cwd, 'node_modules'))).isSymbolicLink()).toBe(true);
-        });
-        const issues = await (0, validate_1.validateDataAppBuild)({
-            appDir: dir,
-            bundle,
-            runCommand,
-        });
-        expect(issues).toEqual([]);
-        expect(runCommand).toHaveBeenCalledOnce();
-    });
-    it('restores custom dependencies with a frozen lockfile before Vite', async () => {
-        const dir = await makeApp({
-            packageJson: JSON.stringify({
-                name: 'custom-app',
-                version: '1.0.0',
-                dependencies: { 'left-pad': '1.3.0' },
-                devDependencies: { malicious: '1.0.0' },
-                scripts: { build: 'tsc --noEmit' },
-            }),
-            lockfile: [
-                "lockfileVersion: '9.0'",
-                'packages:',
-                '  left-pad@1.3.0: {}',
-            ].join('\n'),
-        });
-        const bundle = await (0, appCodeFiles_1.readBundleFromDir)(dir);
-        const commands = [];
-        const runCommand = vi.fn(async (command) => {
-            commands.push(command);
-            if (command.command === 'pnpm') {
-                const packageJson = JSON.parse(await fs_1.promises.readFile(path.join(command.cwd, 'package.json'), 'utf-8'));
-                expect(packageJson.dependencies).toEqual({
-                    'left-pad': '1.3.0',
-                });
-                expect(packageJson.scripts).toEqual(expect.objectContaining({ build: 'vite build' }));
-                expect(packageJson.devDependencies).not.toHaveProperty('malicious');
-            }
-        });
-        const issues = await (0, validate_1.validateDataAppBuild)({
-            appDir: dir,
-            bundle,
-            runCommand,
-        });
-        expect(issues).toEqual([]);
-        expect(commands).toEqual([
-            expect.objectContaining({
-                command: 'pnpm',
-                args: ['install', '--frozen-lockfile', '--ignore-scripts'],
-                env: { CI: 'true' },
-                timeoutMs: 120_000,
-            }),
-            expect.objectContaining({
-                command: 'vite',
-                args: ['build'],
-                preferLocal: true,
-            }),
-        ]);
-    });
-    it('reports Vite output as a build validation error', async () => {
-        const dir = await makeApp();
-        await fs_1.promises.mkdir(path.join(dir, 'node_modules'));
-        const bundle = await (0, appCodeFiles_1.readBundleFromDir)(dir);
-        const viteError = Object.assign(new Error('Command failed'), {
-            stderr: 'src/App.tsx:7: Could not resolve "missing-package"',
-            stdout: 'vite v8 building for production',
-        });
-        const issues = await (0, validate_1.validateDataAppBuild)({
-            appDir: dir,
-            bundle,
-            runCommand: vi.fn().mockRejectedValue(viteError),
-        });
-        expect(issues).toEqual([
-            expect.objectContaining({
-                code: 'build',
-                message: expect.stringContaining('Could not resolve "missing-package"'),
-            }),
-        ]);
-    });
-    it('handles non-object command failures without masking them', async () => {
-        const dir = await makeApp();
-        await fs_1.promises.mkdir(path.join(dir, 'node_modules'));
-        const bundle = await (0, appCodeFiles_1.readBundleFromDir)(dir);
-        const issues = await (0, validate_1.validateDataAppBuild)({
-            appDir: dir,
-            bundle,
-            runCommand: vi.fn().mockRejectedValue(null),
-        });
-        expect(issues).toEqual([
-            expect.objectContaining({
-                code: 'build',
-                message: expect.stringContaining('Unknown object error'),
-            }),
-        ]);
-    });
-    it('requires local template dependencies without installing them', async () => {
-        const dir = await makeApp();
-        const bundle = await (0, appCodeFiles_1.readBundleFromDir)(dir);
-        const runCommand = vi.fn();
-        const issues = await (0, validate_1.validateDataAppBuild)({
-            appDir: dir,
-            bundle,
-            runCommand,
-        });
-        expect(issues).toEqual([
-            expect.objectContaining({
-                code: 'dependencies',
-                message: expect.stringContaining("Run 'npm install'"),
-            }),
-        ]);
-        expect(runCommand).not.toHaveBeenCalled();
-    });
-});
-describe('renderAppsValidationHuman', () => {
-    const report = (0, validate_1.buildAppsValidationReport)([
-        {
-            path: '/tmp/orders-app',
-            name: 'Orders app',
-            projectUuid: 'project-uuid',
-            template: null,
-            valid: true,
-            errors: [],
-            warnings: [],
-            coverage: {
-                callSites: 14,
-                fullyResolved: 11,
-                partiallyResolved: 2,
-                unresolved: 1,
-                unanalyzed: 3,
-            },
-            unanalyzedReferences: [
-                {
-                    kind: 'query',
-                    unresolved: ['explore', 'dimensions'],
-                    location: {
-                        path: 'src/DynamicQuery.tsx',
-                        line: 8,
-                        column: 17,
-                    },
-                },
-                {
-                    kind: 'globalFilter',
-                    unresolved: ['field'],
-                    location: {
-                        path: 'src/ResultsTable.tsx',
-                        line: 42,
-                        column: 21,
-                    },
-                },
-                {
-                    kind: 'externalFetch',
-                    unresolved: ['alias'],
-                    location: {
-                        path: 'src/ExternalData.tsx',
-                        line: 12,
-                        column: 9,
-                    },
-                },
-            ],
-        },
-    ], false, true);
-    it('makes partial green coverage explicit', () => {
-        const output = (0, validate_1.renderAppsValidationHuman)(report);
-        expect(output).toContain("3 of 14 data-reference call site(s) couldn't be fully analyzed");
-        expect(output).toContain('unresolved values were skipped');
-        expect(output).toContain('Validation passed');
-        expect(output).toContain('Offline snapshots may be stale');
-        expect(output).toContain('running Vite production builds');
-        expect(output).not.toContain('Static analysis gaps');
-    });
-    it('lists unresolved call sites and parts in verbose output', () => {
-        const output = (0, validate_1.renderAppsValidationHuman)(report, true);
-        expect(output).toContain('Static analysis gaps:');
-        expect(output).toContain('src/DynamicQuery.tsx:8:17 — query (unresolved: explore, dimensions)');
-        expect(output).toContain('src/ResultsTable.tsx:42:21 — global filter (unresolved: field)');
-    });
-    it('keeps verbose-only reference details out of JSON output', () => {
-        const output = (0, validate_1.renderAppsValidationJson)(report);
-        expect(JSON.parse(output)).not.toHaveProperty('apps.0.unanalyzedReferences');
-    });
-    const buildResult = (template, overrides = {}) => ({
-        path: '/tmp/bundle',
-        name: 'Bundle',
-        projectUuid: null,
-        template,
-        valid: true,
-        errors: [],
-        warnings: [],
-        coverage: {
-            callSites: 0,
-            fullyResolved: 0,
-            partiallyResolved: 0,
-            unresolved: 0,
-            unanalyzed: 0,
-        },
-        unanalyzedReferences: [],
-        ...overrides,
-    });
-    it('describes an all-chart-type run as custom chart types', () => {
-        const vizReport = (0, validate_1.buildAppsValidationReport)([buildResult(common_1.DATA_APP_VIZ_TEMPLATE)], false);
-        const output = (0, validate_1.renderAppsValidationHuman)(vizReport);
-        expect(output).toContain('Validating 1 custom chart type(s)');
-        expect(output).toContain('Validation passed for 1 custom chart type(s)');
-        expect(output).not.toContain('data app(s)');
-        expect(vizReport.summary.chartTypes).toBe(1);
-        expect(vizReport.summary.dataApps).toBe(0);
-    });
-    it('describes a mixed run with both nouns', () => {
-        const mixedReport = (0, validate_1.buildAppsValidationReport)([
-            buildResult(common_1.DATA_APP_VIZ_TEMPLATE, {
-                valid: false,
-                errors: [
-                    { code: 'manifest', message: 'bad', location: null },
-                ],
-            }),
-            buildResult(null),
-        ], false);
-        const output = (0, validate_1.renderAppsValidationHuman)(mixedReport);
-        expect(output).toContain('Validating 1 data app(s) and 1 custom chart type(s)');
-        expect(output).toContain('Validation failed with 1 error(s) across 1 data app(s) and 1 custom chart type(s).');
-    });
-});

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

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

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

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

package/dist/handlers/compile.test.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const common_1 = require("@lightdash/common");
-const promises_1 = tslib_1.__importDefault(require("fs/promises"));
-const os = tslib_1.__importStar(require("os"));
-const path = tslib_1.__importStar(require("path"));
-const lightdashLoader = tslib_1.__importStar(require("../lightdash/loader"));
-const compile_1 = require("./compile");
-vi.mock('execa');
-vi.mock('../analytics/analytics');
-vi.mock('../config', () => ({
-    getConfig: vi.fn().mockResolvedValue({ user: null, context: null }),
-}));
-const modelWithBrokenMetric = {
-    type: 'model',
-    name: 'test_model',
-    description: 'Test model',
-    sql_from: 'SELECT * FROM test_table',
-    dimensions: [
-        {
-            name: 'id',
-            description: 'ID column',
-            type: common_1.DimensionType.NUMBER,
-            sql: 'id',
-        },
-    ],
-    metrics: {
-        broken_metric: {
-            type: common_1.MetricType.SUM,
-            sql: `\${missing_dimension}`,
-        },
-    },
-};
-const getCompileOptions = (projectDir) => ({
-    projectDir,
-    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,
-    combineManifest: undefined,
-    warehouseCredentials: false,
-    disableTimestampConversion: false,
-});
-describe('compile', () => {
-    let tempDir;
-    beforeEach(async () => {
-        vi.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 () => {
-        vi.restoreAllMocks();
-        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)(getCompileOptions(tempDir));
-        // 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');
-        if (startedCall === undefined) {
-            throw new Error('Expected compile.started analytics event');
-        }
-        expect(startedCall[0].properties.dbtVersion).toBeUndefined();
-    });
-    test('should allow partial compilation by default and allow it to be disabled explicitly', async () => {
-        vi.spyOn(lightdashLoader, 'loadLightdashModels').mockResolvedValue([
-            { ...modelWithBrokenMetric, sourcePath: 'models/test_model.yml' },
-        ]);
-        const errorOutput = [];
-        vi.spyOn(console, 'error').mockImplementation((...args) => {
-            errorOutput.push(args.map(String).join(' '));
-        });
-        const partialResult = await (0, compile_1.compile)(getCompileOptions(tempDir));
-        expect(partialResult.filter(common_1.isExploreError)).toHaveLength(0);
-        expect(partialResult.flatMap((explore) => (0, common_1.isExploreError)(explore) ? [] : (explore.warnings ?? []))).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                message: expect.stringContaining('broken_metric'),
-            }),
-        ]));
-        expect(errorOutput).toEqual(expect.arrayContaining([
-            expect.stringContaining('- PARTIAL_SUCCESS> test_model'),
-            expect.stringContaining('Compiled 1 explores, SUCCESS=0 PARTIAL_SUCCESS=1 ERRORS=0'),
-        ]));
-        errorOutput.length = 0;
-        const strictResult = await (0, compile_1.compile)({
-            ...getCompileOptions(tempDir),
-            partialCompilation: false,
-        });
-        expect(strictResult.filter(common_1.isExploreError)).toHaveLength(1);
-        expect(errorOutput).toEqual(expect.arrayContaining([
-            expect.stringContaining('- ERROR> test_model'),
-            expect.stringContaining('Compiled 1 explores, SUCCESS=0 ERRORS=1'),
-        ]));
-    });
-    test('rejects malformed native YAML instead of compiling only the valid models', async () => {
-        await promises_1.default.writeFile(path.join(tempDir, 'lightdash/models/broken.yml'), 'type: model\ndimensions: [');
-        await expect((0, compile_1.compile)(getCompileOptions(tempDir))).rejects.toThrow(/broken.yml/);
-    });
-});

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

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

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

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