@lightdash/cli 2.228.1 → 2.229.0

package/dist/handlers/compileProject.test.js

@@ -1,637 +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 node_fetch_1 = require("node-fetch");
-const os_1 = tslib_1.__importDefault(require("os"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const context_1 = require("../dbt/context");
-const manifest_1 = require("../dbt/manifest");
-const validation_1 = require("../dbt/validation");
-const loader_1 = require("../lightdash/loader");
-const projectType_1 = require("../lightdash/projectType");
-const compile_1 = require("./compile");
-const apiClient_1 = require("./dbt/apiClient");
-const compile_2 = require("./dbt/compile");
-const getDbtVersion_1 = require("./dbt/getDbtVersion");
-vi.mock('../analytics/analytics');
-vi.mock('../config', () => ({
-    getConfig: vi.fn().mockResolvedValue({ user: null, context: null }),
-}));
-vi.mock('../dbt/context');
-vi.mock('../dbt/manifest', async (importOriginal) => ({
-    ...(await importOriginal()),
-    loadCombineManifest: vi.fn(),
-    loadManifest: vi.fn(),
-}));
-vi.mock('../dbt/validation');
-vi.mock('../lightdash/loader');
-vi.mock('./dbt/compile');
-vi.mock('./dbt/getDbtVersion');
-vi.mock('./dbt/apiClient', async (importOriginal) => ({
-    ...(await importOriginal()),
-    lightdashRawApi: vi.fn(),
-}));
-const dbtNode = (uniqueId, resourceType, compiled, extra = {}) => ({
-    unique_id: uniqueId,
-    name: uniqueId.split('.').at(-1) ?? uniqueId,
-    resource_type: resourceType,
-    package_name: 'test',
-    path: `${uniqueId}.sql`,
-    original_file_path: `models/${uniqueId}.sql`,
-    alias: uniqueId.split('.').at(-1) ?? uniqueId,
-    checksum: { name: 'sha256', checksum: uniqueId },
-    tags: [],
-    refs: [],
-    sources: [],
-    depends_on: { macros: [], nodes: [] },
-    database: 'db',
-    schema: 'public',
-    fqn: ['test', uniqueId],
-    raw_code: 'SELECT 1',
-    columns: {
-        id: {
-            name: 'id',
-            data_type: common_1.DimensionType.NUMBER,
-            meta: {},
-        },
-    },
-    meta: {},
-    description: '',
-    created_at: 0,
-    language: 'sql',
-    relation_name: `"db"."public"."${uniqueId}"`,
-    config: { materialized: 'table' },
-    compiled,
-    ...extra,
-});
-const manifest = (nodes) => ({
-    metadata: {
-        dbt_schema_version: 'https://schemas.getdbt.com/dbt/manifest/v12.json',
-        generated_at: '2026-01-01T00:00:00Z',
-        adapter_type: 'postgres',
-    },
-    nodes,
-    sources: {},
-    macros: {},
-    docs: {},
-    exposures: {},
-    metrics: {},
-});
-const compileOptions = (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('compileProject completeness', () => {
-    let tempDir;
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        tempDir = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'lightdash-compile-project-test-'));
-        await promises_1.default.writeFile(path_1.default.join(tempDir, 'lightdash.config.yml'), 'warehouse:\n  type: postgres\n');
-        vi.mocked(getDbtVersion_1.tryGetDbtVersion).mockResolvedValue({
-            success: true,
-            version: {
-                verboseVersion: '1.10.19',
-                versionOption: common_1.SupportedDbtVersions.V1_10,
-                isDbtCloudCLI: false,
-                isDbtFusion: false,
-            },
-        });
-        vi.mocked(context_1.getDbtContext).mockResolvedValue({
-            projectName: 'test_project',
-            profileName: 'test_profile',
-            targetDir: path_1.default.join(tempDir, 'target'),
-            modelsDir: 'models',
-        });
-        vi.mocked(loader_1.loadLightdashModels).mockResolvedValue([]);
-        vi.mocked(validation_1.validateDbtModel).mockImplementation(async (_adapter, _version, models) => ({
-            valid: models,
-            invalid: [],
-            skipped: [],
-        }));
-        vi.spyOn(console, 'error').mockImplementation(() => undefined);
-        vi.spyOn(console, 'info').mockImplementation(() => undefined);
-    });
-    afterEach(async () => {
-        vi.restoreAllMocks();
-        await promises_1.default.rm(tempDir, { recursive: true, force: true });
-    });
-    test.each([false, true])('compiles dbt when ignored YAML is malformed, symlinked models: %s', async (symlinkedModels) => {
-        const projectDir = path_1.default.join(tempDir, 'dbt-project');
-        const modelsDir = symlinkedModels
-            ? path_1.default.join(tempDir, 'shared-models')
-            : path_1.default.join(projectDir, 'models');
-        await promises_1.default.mkdir(projectDir);
-        await promises_1.default.mkdir(modelsDir);
-        if (symlinkedModels)
-            await promises_1.default.symlink(modelsDir, path_1.default.join(projectDir, 'models'));
-        await promises_1.default.writeFile(path_1.default.join(projectDir, 'dbt_project.yml'), 'name: test_project\nversion: "1.0"\nconfig-version: 2\n');
-        await promises_1.default.writeFile(path_1.default.join(projectDir, '.dbtignore'), 'models/archived.yml\n');
-        await promises_1.default.writeFile(path_1.default.join(modelsDir, 'schema.yml'), 'version: 2\nmodels:\n  - name: orders\n');
-        await promises_1.default.writeFile(path_1.default.join(modelsDir, 'archived.yml'), 'archived: [unfinished\n');
-        const loader = await vi.importActual('../lightdash/loader');
-        vi.mocked(loader_1.findLightdashModelFiles).mockImplementationOnce(loader.findLightdashModelFiles);
-        vi.mocked(loader_1.loadLightdashModels).mockImplementationOnce(loader.loadLightdashModels);
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        }));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        await expect((0, projectType_1.detectProjectType)({ projectDir })).resolves.toMatchObject({ type: projectType_1.CliProjectType.Dbt });
-        const result = await (0, compile_1.compileProject)(compileOptions(projectDir));
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-        ]);
-        expect(compile_2.maybeCompileModelsAndJoins).toHaveBeenCalled();
-    });
-    test('reports an unselected model and seed manifest as complete', async () => {
-        const projectManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-            'seed.test.countries': dbtNode('seed.test.countries', 'seed', false),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)(compileOptions(tempDir));
-        expect(result.isProjectComplete).toBe(true);
-        expect(result.dbtModelNames).toEqual([
-            'orders',
-            'test__orders',
-            'countries',
-            'test__countries',
-        ]);
-    });
-    test('reports a selected subset as incomplete', async () => {
-        const projectManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-            'model.test.customers': dbtNode('model.test.customers', 'model', true),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: ['model.test.orders'],
-        });
-        const result = await (0, compile_1.compileProject)(compileOptions(tempDir));
-        expect(result.isProjectComplete).toBe(false);
-        expect(result.dbtModelNames).toEqual([
-            'orders',
-            'test__orders',
-            'customers',
-            'test__customers',
-        ]);
-    });
-    test('omits cleanup inventory for YAML projects', async () => {
-        vi.mocked(loader_1.loadLightdashModels).mockResolvedValue([
-            {
-                type: 'model',
-                name: 'orders',
-                sql_from: 'SELECT 1 AS id',
-                dimensions: [
-                    { name: 'id', type: common_1.DimensionType.NUMBER, sql: 'id' },
-                ],
-                sourcePath: 'models/orders.yml',
-            },
-        ]);
-        const result = await (0, compile_1.compileProject)(compileOptions(tempDir));
-        expect(result.dbtModelNames).toBeUndefined();
-        expect(manifest_1.loadManifest).not.toHaveBeenCalled();
-    });
-    test.each(['lightdash_source_name', 'lightdash_source_uuid'])('omits cleanup inventory for a manifest annotated with %s', async (sourceField) => {
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true, {
-                [sourceField]: 'source-a',
-            }),
-        }));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)(compileOptions(tempDir));
-        expect(result.dbtModelNames).toBeUndefined();
-    });
-    test('derives completeness before combining an external manifest', async () => {
-        const projectManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        });
-        const externalManifest = manifest({
-            'model.external.compiled': dbtNode('model.external.compiled', 'model', true),
-            'model.external.uncompiled': dbtNode('model.external.uncompiled', 'model', false),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(manifest_1.loadCombineManifest).mockResolvedValue(externalManifest);
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifest: 'external-manifest.json',
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.isProjectComplete).toBe(true);
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-            'compiled',
-        ]);
-        expect(result.dbtModelNames).toBeUndefined();
-        expect(apiClient_1.lightdashRawApi).not.toHaveBeenCalled();
-        expect(console.info).toHaveBeenCalledWith(expect.stringContaining('Combined external manifest from'));
-    });
-    test('projects, merges, and compiles served-only models while preserving local precedence and source identity', async () => {
-        const projectManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true, {
-                description: 'Local orders description',
-            }),
-        });
-        const servedManifest = (0, common_1.projectMergedManifest)(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true, {
-                description: 'Served orders description',
-                lightdash_source_name: 'local_source',
-            }),
-            'model.served.customers': dbtNode('model.served.customers', 'model', true, {
-                package_name: 'served',
-                lightdash_source_name: 'served_source',
-            }),
-            'model.served.customer_helper': dbtNode('model.served.customer_helper', 'model', false, {
-                package_name: 'served',
-                lightdash_source_name: 'served_source',
-            }),
-        }));
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-            'customers',
-        ]);
-        expect(result.isProjectComplete).toBe(true);
-        expect(result.dbtModelNames).toBeUndefined();
-        expect(apiClient_1.lightdashRawApi).toHaveBeenCalledWith({
-            method: 'GET',
-            url: '/api/v1/projects/project-uuid/dbt/manifest',
-            body: undefined,
-        });
-        expect(console.info).toHaveBeenCalledWith(expect.stringMatching(/added [1-9]\d* model\(s\)/));
-        const modelsForValidation = vi.mocked(validation_1.validateDbtModel).mock.calls[0][2];
-        const localModel = modelsForValidation.find((model) => model.unique_id === 'model.test.orders');
-        expect(localModel.description).toBe('Local orders description');
-        expect(localModel.lightdash_source_name).toBe('local_source');
-        expect(modelsForValidation.map((model) => model.unique_id)).not.toContain('model.served.customer_helper');
-        expect(vi.mocked(validation_1.validateDbtModel).mock.calls[0][3]).toEqual(new Set(['model.served.customers']));
-    });
-    test('replaces the complete local source while retaining served models from other sources', async () => {
-        const projectManifest = manifest({
-            'model.local.orders': dbtNode('model.local.orders', 'model', true, {
-                description: 'Local orders description',
-            }),
-        });
-        const servedManifest = (0, common_1.projectMergedManifest)(manifest({
-            'model.local.orders': dbtNode('model.local.orders', 'model', true, {
-                description: 'Served orders description',
-                lightdash_source_name: 'local_source',
-            }),
-            'model.local.deleted': dbtNode('model.local.deleted', 'model', true, {
-                lightdash_source_name: 'local_source',
-            }),
-            'model.other.customers': dbtNode('model.other.customers', 'model', true, {
-                lightdash_source_name: 'other_source',
-            }),
-        }));
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.local.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.isProjectComplete).toBe(true);
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-            'customers',
-        ]);
-        const modelsForValidation = vi.mocked(validation_1.validateDbtModel).mock.calls[0][2];
-        expect(modelsForValidation).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                unique_id: 'model.local.orders',
-                description: 'Local orders description',
-                lightdash_source_name: 'local_source',
-            }),
-            expect.objectContaining({
-                unique_id: 'model.other.customers',
-                lightdash_source_name: 'other_source',
-            }),
-        ]));
-        expect(modelsForValidation.map((model) => model.unique_id)).not.toContain('model.local.deleted');
-    });
-    test('additively combines selective local models with compiled served collision candidates', async () => {
-        const projectManifest = manifest({
-            'model.source_a.orders': dbtNode('model.source_a.orders', 'model', true, {
-                description: 'Local selected orders',
-            }),
-            'model.source_a.customers': dbtNode('model.source_a.customers', 'model', true, {
-                description: 'Local unselected customers',
-            }),
-        });
-        const servedManifest = (0, common_1.projectMergedManifest)(manifest({
-            'model.source_a.orders': dbtNode('model.source_a.orders', 'model', true, {
-                description: 'Served selected orders',
-                lightdash_source_name: 'source_a',
-            }),
-            'model.source_a.customers': dbtNode('model.source_a.customers', 'model', true, {
-                description: 'Served unselected customers',
-                lightdash_source_name: 'source_a',
-            }),
-            'model.source_a.deleted': dbtNode('model.source_a.deleted', 'model', true, {
-                lightdash_source_name: 'source_a',
-            }),
-            'model.source_b.customers': dbtNode('model.source_b.customers', 'model', true, {
-                lightdash_source_name: 'source_b',
-            }),
-        }));
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.source_a.orders'],
-            originallySelectedModelIds: ['model.source_a.orders'],
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.isProjectComplete).toBe(false);
-        const modelsForValidation = vi.mocked(validation_1.validateDbtModel).mock.calls[0][2];
-        expect(modelsForValidation).toEqual(expect.arrayContaining([
-            expect.objectContaining({
-                unique_id: 'model.source_a.orders',
-                description: 'Local selected orders',
-                lightdash_source_name: 'source_a',
-            }),
-            expect.objectContaining({
-                unique_id: 'model.source_a.customers',
-                description: 'Served unselected customers',
-                compiled: true,
-                lightdash_source_name: 'source_a',
-            }),
-            expect.objectContaining({
-                unique_id: 'model.source_a.deleted',
-                lightdash_source_name: 'source_a',
-            }),
-            expect.objectContaining({
-                unique_id: 'model.source_b.customers',
-                lightdash_source_name: 'source_b',
-            }),
-        ]));
-        const unselectedCollisionCandidates = modelsForValidation.filter((model) => model.name === 'customers');
-        expect(unselectedCollisionCandidates.map((model) => ({
-            uniqueId: model.unique_id,
-            sourceName: model.lightdash_source_name,
-        }))).toEqual([
-            {
-                uniqueId: 'model.source_a.customers',
-                sourceName: 'source_a',
-            },
-            {
-                uniqueId: 'model.source_b.customers',
-                sourceName: 'source_b',
-            },
-        ]);
-    });
-    test('rejects automatic combination when overlaps identify multiple local sources', async () => {
-        const projectManifest = manifest({
-            'model.local.orders': dbtNode('model.local.orders', 'model', true),
-            'model.local.customers': dbtNode('model.local.customers', 'model', true),
-        });
-        const servedManifest = manifest({
-            'model.local.orders': dbtNode('model.local.orders', 'model', true, {
-                lightdash_source_name: 'source_a',
-            }),
-            'model.local.customers': dbtNode('model.local.customers', 'model', true, {
-                lightdash_source_name: 'source_c',
-            }),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.local.orders', 'model.local.customers'],
-            originallySelectedModelIds: undefined,
-        });
-        await expect((0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        })).rejects.toThrow('Cannot automatically combine manifest from the server: overlapping local models match multiple Lightdash sources (source_a, source_c)');
-        expect(validation_1.validateDbtModel).not.toHaveBeenCalled();
-    });
-    test('skips automatic combination when the local dbt project is not a served source', async () => {
-        const projectManifest = manifest({
-            'model.local.orders': dbtNode('model.local.orders', 'model', true),
-        });
-        const servedManifest = manifest({
-            'model.served.customers': dbtNode('model.served.customers', 'model', true),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.local.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-        ]);
-        expect(console.info).toHaveBeenCalledWith(expect.stringContaining('the local dbt project is not a source of this Lightdash project'));
-    });
-    test('explains when a matching served manifest has no compiled models', async () => {
-        const projectManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        });
-        const servedManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', false, {
-                lightdash_source_name: 'local_source',
-            }),
-            'model.served.helper': dbtNode('model.served.helper', 'model', false),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(console.info).toHaveBeenCalledWith(expect.stringContaining('contains no compiled models'));
-    });
-    test('explains when all compiled served models already overlap locally', async () => {
-        const projectManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        });
-        const servedManifest = manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true, {
-                lightdash_source_name: 'local_source',
-            }),
-        });
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(projectManifest);
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(servedManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(console.info).toHaveBeenCalledWith(expect.stringContaining('all compiled models already exist in the preview manifest'));
-    });
-    test('notices when no served manifest exists and keeps the local manifest', async () => {
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        }));
-        vi.mocked(apiClient_1.lightdashRawApi).mockRejectedValue(new common_1.LightdashError({
-            message: 'Manifest not found',
-            name: 'NotFoundError',
-            statusCode: 404,
-            data: {},
-        }));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-        ]);
-        expect(console.error).not.toHaveBeenCalledWith(expect.stringContaining('Could not fetch the server manifest'));
-        expect(console.info).toHaveBeenCalledWith(expect.stringContaining('No server manifest found; continuing with the preview manifest'));
-    });
-    test.each([
-        ['a null response', null],
-        ['an array of nodes', { metadata: {}, nodes: [] }],
-        ['array metadata', { metadata: [], nodes: {} }],
-        ['missing metadata', { nodes: {} }],
-    ])('rejects %s from the server manifest endpoint and keeps the local manifest', async (_description, invalidManifest) => {
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        }));
-        vi.mocked(apiClient_1.lightdashRawApi).mockResolvedValue(new node_fetch_1.Response(JSON.stringify(invalidManifest)));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-        ]);
-        expect(console.error).toHaveBeenCalledWith(expect.stringContaining('/api/v1/projects/project-uuid/dbt/manifest returned an invalid manifest'));
-    });
-    test.each([
-        [
-            'an authorization error',
-            new common_1.LightdashError({
-                message: 'Not authorized',
-                name: 'AuthorizationError',
-                statusCode: 401,
-                data: {},
-            }),
-        ],
-        [
-            'a server error',
-            new common_1.LightdashError({
-                message: 'Server unavailable',
-                name: 'InternalServerError',
-                statusCode: 500,
-                data: {},
-            }),
-        ],
-        [
-            'a permission error',
-            new common_1.LightdashError({
-                message: 'Forbidden',
-                name: 'ForbiddenError',
-                statusCode: 403,
-                data: {},
-            }),
-        ],
-        ['a network error', new Error('Connection refused')],
-    ])('warns once and keeps the local manifest after %s', async (_description, error) => {
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        }));
-        vi.mocked(apiClient_1.lightdashRawApi).mockRejectedValue(error);
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        const result = await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(result.explores.map((explore) => explore.name)).toEqual([
-            'orders',
-        ]);
-        expect(vi
-            .mocked(console.error)
-            .mock.calls.filter(([message]) => String(message).includes('Could not fetch the server manifest'))).toHaveLength(1);
-    });
-    test('does not fetch a served manifest when manifest combining is disabled', async () => {
-        vi.mocked(manifest_1.loadManifest).mockResolvedValue(manifest({
-            'model.test.orders': dbtNode('model.test.orders', 'model', true),
-        }));
-        vi.mocked(compile_2.maybeCompileModelsAndJoins).mockResolvedValue({
-            compiledModelIds: ['model.test.orders'],
-            originallySelectedModelIds: undefined,
-        });
-        await (0, compile_1.compileProject)({
-            ...compileOptions(tempDir),
-            combine: false,
-            combineManifestProjectUuid: 'project-uuid',
-        });
-        expect(apiClient_1.lightdashRawApi).not.toHaveBeenCalled();
-    });
-});

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

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

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

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