@lightdash/cli 2.228.1 → 2.229.0

package/dist/dbt/targets/athena.test.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@lightdash/common");
-const athena_1 = require("./athena");
-describe('convertAthenaSchema', () => {
-    test('should parse access key authentication when keys are present', () => {
-        const target = {
-            type: 'athena',
-            region_name: 'us-east-1',
-            database: 'AwsDataCatalog',
-            schema: 'default',
-            s3_staging_dir: 's3://test-results/',
-            aws_access_key_id: 'AKIATEST',
-            aws_secret_access_key: 'SECRETTEST',
-        };
-        expect((0, athena_1.convertAthenaSchema)(target)).toEqual({
-            type: common_1.WarehouseTypes.ATHENA,
-            region: 'us-east-1',
-            database: 'AwsDataCatalog',
-            schema: 'default',
-            s3StagingDir: 's3://test-results/',
-            s3DataDir: undefined,
-            authenticationType: common_1.AthenaAuthenticationType.ACCESS_KEY,
-            accessKeyId: 'AKIATEST',
-            secretAccessKey: 'SECRETTEST',
-            workGroup: undefined,
-            threads: undefined,
-            numRetries: undefined,
-        });
-    });
-    test('should parse iam role authentication when keys are missing', () => {
-        const target = {
-            type: 'athena',
-            region_name: 'us-east-1',
-            database: 'AwsDataCatalog',
-            schema: 'default',
-            s3_staging_dir: 's3://test-results/',
-        };
-        expect((0, athena_1.convertAthenaSchema)(target)).toEqual({
-            type: common_1.WarehouseTypes.ATHENA,
-            region: 'us-east-1',
-            database: 'AwsDataCatalog',
-            schema: 'default',
-            s3StagingDir: 's3://test-results/',
-            s3DataDir: undefined,
-            authenticationType: common_1.AthenaAuthenticationType.IAM_ROLE,
-            accessKeyId: undefined,
-            secretAccessKey: undefined,
-            workGroup: undefined,
-            threads: undefined,
-            numRetries: undefined,
-        });
-    });
-    test('should forward aws_session_token as sessionToken for temporary STS credentials', () => {
-        const target = {
-            type: 'athena',
-            region_name: 'us-east-1',
-            database: 'AwsDataCatalog',
-            schema: 'default',
-            s3_staging_dir: 's3://test-results/',
-            aws_access_key_id: 'ASIATEST',
-            aws_secret_access_key: 'SECRETTEST',
-            aws_session_token: 'SESSIONTOKENTEST',
-        };
-        expect((0, athena_1.convertAthenaSchema)(target)).toMatchObject({
-            authenticationType: common_1.AthenaAuthenticationType.ACCESS_KEY,
-            accessKeyId: 'ASIATEST',
-            secretAccessKey: 'SECRETTEST',
-            sessionToken: 'SESSIONTOKENTEST',
-        });
-    });
-    test('should throw parse error for invalid Athena target', () => {
-        expect(() => (0, athena_1.convertAthenaSchema)({
-            type: 'athena',
-            region_name: 'us-east-1',
-        })).toThrow(common_1.ParseError);
-    });
-});

package/dist/dbt/targets/duckdb.test.d.ts

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

package/dist/dbt/targets/duckdb.test.d.ts.map

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

package/dist/dbt/targets/duckdb.test.js

@@ -1,149 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@lightdash/common");
-const duckdb_1 = require("./duckdb");
-describe('convertDuckdbSchema', () => {
-    test('should parse MotherDuck duckdb targets', () => {
-        expect((0, duckdb_1.convertDuckdbSchema)({
-            type: 'duckdb',
-            path: 'md:analytics',
-            schema: 'main',
-            threads: 4,
-            settings: {
-                motherduck_token: 'motherduck_token',
-            },
-        })).toEqual({
-            type: common_1.WarehouseTypes.DUCKDB,
-            connectionType: common_1.DuckdbConnectionType.MOTHERDUCK,
-            database: 'analytics',
-            schema: 'main',
-            token: 'motherduck_token',
-            threads: 4,
-        });
-    });
-    test('should parse MotherDuck duckdb targets with token in path query string', () => {
-        expect((0, duckdb_1.convertDuckdbSchema)({
-            type: 'duckdb',
-            path: 'md:analytics?motherduck_token=motherduck_token',
-            schema: 'main',
-            threads: 4,
-        })).toEqual({
-            type: common_1.WarehouseTypes.DUCKDB,
-            connectionType: common_1.DuckdbConnectionType.MOTHERDUCK,
-            database: 'analytics',
-            schema: 'main',
-            token: 'motherduck_token',
-            threads: 4,
-        });
-    });
-    test('should reject duckdb targets that are neither MotherDuck nor DuckLake', () => {
-        expect(() => (0, duckdb_1.convertDuckdbSchema)({
-            type: 'duckdb',
-            path: 'analytics.duckdb',
-            schema: 'main',
-        })).toThrow(common_1.ParseError);
-    });
-    test('should require a MotherDuck token', () => {
-        expect(() => (0, duckdb_1.convertDuckdbSchema)({
-            type: 'duckdb',
-            path: 'md:analytics',
-            schema: 'main',
-        })).toThrow(common_1.ParseError);
-    });
-    test('should parse a DuckLake target with postgres catalog and S3 data path', () => {
-        expect((0, duckdb_1.convertDuckdbSchema)({
-            type: 'duckdb',
-            path: ':memory:',
-            schema: 'main',
-            threads: 4,
-            attach: [
-                {
-                    path: 'ducklake:ld_ducklake',
-                    alias: 'ducklake',
-                },
-            ],
-            secrets: [
-                {
-                    name: 'ld_ducklake_catalog',
-                    type: 'postgres',
-                    host: 'pg.example.com',
-                    port: 5432,
-                    database: 'catalog',
-                    user: 'ducklake_user',
-                    password: 'p@ss',
-                },
-                {
-                    name: 'ld_ducklake_data',
-                    type: 's3',
-                    scope: 's3://my-bucket/path/',
-                    region: 'us-east-1',
-                    key_id: 'AKIAEXAMPLE',
-                    secret: 'SECRETEXAMPLE',
-                    url_style: 'vhost',
-                    use_ssl: true,
-                },
-                {
-                    name: 'ld_ducklake',
-                    type: 'ducklake',
-                    data_path: 's3://my-bucket/path/',
-                    metadata_parameters: {
-                        TYPE: 'postgres',
-                        SECRET: 'ld_ducklake_catalog',
-                    },
-                },
-            ],
-        })).toEqual({
-            type: common_1.WarehouseTypes.DUCKDB,
-            connectionType: common_1.DuckdbConnectionType.DUCKLAKE,
-            schema: 'main',
-            catalogAlias: 'ducklake',
-            threads: 4,
-            catalog: {
-                type: common_1.DucklakeCatalogType.POSTGRES,
-                host: 'pg.example.com',
-                port: 5432,
-                database: 'catalog',
-                user: 'ducklake_user',
-                password: 'p@ss',
-            },
-            dataPath: {
-                type: common_1.DucklakeDataPathType.S3,
-                url: 's3://my-bucket/path/',
-                endpoint: undefined,
-                region: 'us-east-1',
-                accessKeyId: 'AKIAEXAMPLE',
-                secretAccessKey: 'SECRETEXAMPLE',
-                forcePathStyle: false,
-                useSsl: true,
-            },
-        });
-    });
-    test('should parse a DuckLake target with SQLite catalog and local data path', () => {
-        expect((0, duckdb_1.convertDuckdbSchema)({
-            type: 'duckdb',
-            path: ':memory:',
-            schema: 'main',
-            attach: [
-                {
-                    path: 'ducklake:sqlite:/tmp/ducklake.sqlite',
-                    alias: 'ducklake',
-                    options: { data_path: '/tmp/ducklake-data' },
-                },
-            ],
-        })).toEqual({
-            type: common_1.WarehouseTypes.DUCKDB,
-            connectionType: common_1.DuckdbConnectionType.DUCKLAKE,
-            schema: 'main',
-            catalogAlias: 'ducklake',
-            threads: undefined,
-            catalog: {
-                type: common_1.DucklakeCatalogType.SQLITE,
-                path: '/tmp/ducklake.sqlite',
-            },
-            dataPath: {
-                type: common_1.DucklakeDataPathType.LOCAL,
-                path: '/tmp/ducklake-data',
-            },
-        });
-    });
-});

package/dist/dbt/targets/redshift.test.d.ts

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

package/dist/dbt/targets/redshift.test.d.ts.map

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

package/dist/dbt/targets/redshift.test.js

@@ -1,198 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const credential_providers_1 = require("@aws-sdk/credential-providers");
-const common_1 = require("@lightdash/common");
-const redshift_1 = require("./redshift");
-vi.mock('@aws-sdk/credential-providers', () => ({
-    fromIni: vi.fn(),
-    fromNodeProviderChain: vi.fn(),
-}));
-const mockedFromIni = vi.mocked(credential_providers_1.fromIni);
-const mockedFromNodeProviderChain = vi.mocked(credential_providers_1.fromNodeProviderChain);
-// Build a credential provider (the thunk fromIni/fromNodeProviderChain return)
-// that resolves to the given AWS credentials.
-const providerResolving = (credentials) => vi.fn().mockResolvedValue(credentials);
-// ...or rejects, the way the SDK does when nothing in the chain resolves
-// (e.g. an expired SSO session, or no credentials at all).
-const providerRejecting = (message) => vi.fn().mockRejectedValue(new Error(message));
-describe('convertRedshiftSchema', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    test('should parse password authentication', async () => {
-        const target = {
-            type: 'redshift',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            user: 'analytics',
-            password: 'secret',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        };
-        expect(await (0, redshift_1.convertRedshiftSchema)(target)).toEqual({
-            type: common_1.WarehouseTypes.REDSHIFT,
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            user: 'analytics',
-            password: 'secret',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-            keepalivesIdle: undefined,
-            sslmode: undefined,
-        });
-    });
-    test('should resolve IAM credentials from the default AWS chain for a provisioned cluster', async () => {
-        mockedFromNodeProviderChain.mockReturnValue(providerResolving({
-            accessKeyId: 'test-access-key-id-value',
-            secretAccessKey: 'super-secret-access-key',
-        }));
-        const target = {
-            type: 'redshift',
-            method: 'iam',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            cluster_id: 'my-cluster',
-            user: 'analytics',
-            region: 'us-east-1',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-            autocreate: true,
-        };
-        expect(await (0, redshift_1.convertRedshiftSchema)(target)).toEqual({
-            type: common_1.WarehouseTypes.REDSHIFT,
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            user: 'analytics',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-            keepalivesIdle: undefined,
-            sslmode: undefined,
-            authenticationType: common_1.RedshiftAuthenticationType.IAM,
-            region: 'us-east-1',
-            isServerless: false,
-            clusterIdentifier: 'my-cluster',
-            accessKeyId: 'test-access-key-id-value',
-            secretAccessKey: 'super-secret-access-key',
-            autoCreate: true,
-        });
-        // No named profile -> resolve via the default provider chain.
-        expect(mockedFromNodeProviderChain).toHaveBeenCalledTimes(1);
-        expect(mockedFromIni).not.toHaveBeenCalled();
-    });
-    test('should resolve a named iam_profile via fromIni and forward a session token for serverless (derived from host)', async () => {
-        mockedFromIni.mockReturnValue(providerResolving({
-            accessKeyId: 'test-access-key-id-value',
-            secretAccessKey: 'super-secret-access-key',
-            sessionToken: 'temporary-session-token',
-        }));
-        const target = {
-            type: 'redshift',
-            method: 'iam',
-            host: 'my-wg.123.us-east-1.redshift-serverless.amazonaws.com',
-            iam_profile: 'my-sso-profile',
-            region: 'us-east-1',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        };
-        expect(await (0, redshift_1.convertRedshiftSchema)(target)).toEqual({
-            type: common_1.WarehouseTypes.REDSHIFT,
-            host: 'my-wg.123.us-east-1.redshift-serverless.amazonaws.com',
-            user: '',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-            keepalivesIdle: undefined,
-            sslmode: undefined,
-            authenticationType: common_1.RedshiftAuthenticationType.IAM,
-            region: 'us-east-1',
-            isServerless: true,
-            workgroupName: 'my-wg',
-            accessKeyId: 'test-access-key-id-value',
-            secretAccessKey: 'super-secret-access-key',
-            sessionToken: 'temporary-session-token',
-            autoCreate: undefined,
-        });
-        // The dbt "iam_profile" is passed straight through to fromIni so we
-        // resolve the exact identity dbt would use (matching its precedence).
-        expect(mockedFromIni).toHaveBeenCalledWith({
-            profile: 'my-sso-profile',
-        });
-        expect(mockedFromNodeProviderChain).not.toHaveBeenCalled();
-    });
-    test('should warn when forwarding temporary (expiring) credentials', async () => {
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-        const expiration = new Date('2026-07-07T12:00:00.000Z');
-        mockedFromNodeProviderChain.mockReturnValue(providerResolving({
-            accessKeyId: 'test-access-key-id-value',
-            secretAccessKey: 'super-secret-access-key',
-            sessionToken: 'temporary-session-token',
-            expiration,
-        }));
-        await (0, redshift_1.convertRedshiftSchema)({
-            type: 'redshift',
-            method: 'iam',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            cluster_id: 'my-cluster',
-            user: 'analytics',
-            region: 'us-east-1',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        });
-        expect(warnSpy).toHaveBeenCalledTimes(1);
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining(expiration.toISOString()));
-        warnSpy.mockRestore();
-    });
-    test('should throw when IAM target is missing a region', async () => {
-        await expect((0, redshift_1.convertRedshiftSchema)({
-            type: 'redshift',
-            method: 'iam',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            cluster_id: 'my-cluster',
-            user: 'analytics',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        })).rejects.toThrow(common_1.ParseError);
-    });
-    test('should throw a clear error when the default AWS credential chain resolves nothing', async () => {
-        mockedFromNodeProviderChain.mockReturnValue(providerRejecting('Could not load credentials from any providers'));
-        await expect((0, redshift_1.convertRedshiftSchema)({
-            type: 'redshift',
-            method: 'iam',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            cluster_id: 'my-cluster',
-            user: 'analytics',
-            region: 'us-east-1',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        })).rejects.toThrow(common_1.ParseError);
-    });
-    test('should throw an error naming the profile and "aws sso login" when a named profile cannot be resolved', async () => {
-        mockedFromIni.mockReturnValue(providerRejecting('Token for sso-session shared-aws-profile is expired'));
-        await expect((0, redshift_1.convertRedshiftSchema)({
-            type: 'redshift',
-            method: 'iam',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            cluster_id: 'my-cluster',
-            user: 'analytics',
-            region: 'us-east-1',
-            iam_profile: 'shared-aws-profile',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        })).rejects.toThrow(/aws sso login --profile shared-aws-profile/);
-    });
-    test('should throw when password target has no password', async () => {
-        await expect((0, redshift_1.convertRedshiftSchema)({
-            type: 'redshift',
-            host: 'cluster.abc.us-east-1.redshift.amazonaws.com',
-            user: 'analytics',
-            port: 5439,
-            dbname: 'dev',
-            schema: 'public',
-        })).rejects.toThrow(common_1.ParseError);
-    });
-});

package/dist/dbt/templating.test.d.ts

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

package/dist/dbt/templating.test.d.ts.map

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

package/dist/dbt/templating.test.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const templating_1 = require("./templating");
-describe('Templating', () => {
-    const { env, argv } = process;
-    beforeEach(() => {
-        vi.resetModules();
-        process.env = { ...env };
-        process.argv = { ...argv };
-    });
-    afterEach(() => {
-        process.env = env;
-        process.argv = argv;
-    });
-    describe('renderProfilesYml', () => {
-        describe('env_var()', () => {
-            test('should not escape values', () => {
-                process.env.SPAN = '<span>';
-                expect((0, templating_1.renderProfilesYml)("{{ env_var('SPAN') }}")).toBe('<span>');
-                process.env.WINDOWS_PATH = 'C:\\example';
-                expect((0, templating_1.renderProfilesYml)("{{ env_var('WINDOWS_PATH') }}")).toBe('C:\\example');
-            });
-            test('should convert env_var functions and return env var values', () => {
-                process.env.DBT_USER = 'test';
-                expect((0, templating_1.renderProfilesYml)("{{ env_var('DBT_USER') }}")).toBe('test');
-                process.env.DBT_ENV_SECRET_HOST_DOMAIN = 'domain';
-                process.env.DBT_ENV_SECRET_HOST_PATH = 'host_path';
-                expect((0, templating_1.renderProfilesYml)("www.{{ env_var('DBT_ENV_SECRET_HOST_DOMAIN') }}.com/{{ env_var('DBT_ENV_SECRET_HOST_PATH') }}")).toBe('www.domain.com/host_path');
-            });
-            test('should convert env_var function with number conversion', () => {
-                process.env.REDSHIFT_PORT = '2000';
-                expect((0, templating_1.renderProfilesYml)("{{ env_var('REDSHIFT_PORT') | as_number}}")).toBe('2000');
-            });
-            test('should convert env_var function and fallback to default value', () => {
-                expect((0, templating_1.renderProfilesYml)("{{ env_var('DBT_USER', 'default_value') }}")).toBe('default_value');
-            });
-            test('should convert env_var function and fallback to default value using keyword default', () => {
-                expect((0, templating_1.renderProfilesYml)("{{ env_var('DBT_USER', default='default_value') }}")).toBe('default_value');
-            });
-        });
-        describe('var()', () => {
-            test('should convert var functions and return env var values', () => {
-                process.argv = [
-                    '--vars',
-                    '{"domain": "domain", "host_path": "host_path"}',
-                ];
-                expect((0, templating_1.renderProfilesYml)("www.{{ var('domain') }}.com/{{ var('host_path') }}")).toBe('www.domain.com/host_path');
-            });
-        });
-    });
-});

package/dist/dbt/validation.test.d.ts

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

package/dist/dbt/validation.test.d.ts.map

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

package/dist/dbt/validation.test.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@lightdash/common");
-const validation_1 = require("@lightdash/common/dbt/validation");
-const validation_2 = require("./validation");
-const makeModel = (name) => ({
-    unique_id: `model.test.${name}`,
-    name,
-    resource_type: 'model',
-    database: 'database',
-    columns: { id: { name: 'id', meta: {} } },
-    meta: {},
-});
-describe('validateDbtModel', () => {
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    test('directs served manifest validation failures to a project redeploy', async () => {
-        const validationMessage = 'Model "served_orders" from dbt source "server": Field at model root must have required property \'original_file_path\'. Update this field in your dbt model, then deploy again.';
-        const invalidValidator = Object.assign(vi.fn().mockReturnValue(false), {
-            errors: [],
-        });
-        vi.spyOn(validation_1.ManifestValidator, 'getValidator').mockReturnValue(invalidValidator);
-        vi.spyOn(validation_1.ManifestValidator, 'formatAjvErrors').mockReturnValue(validationMessage);
-        const servedModel = makeModel('served_orders');
-        const localModel = makeModel('local_orders');
-        const result = await (0, validation_2.validateDbtModel)('postgres', common_1.DbtManifestVersion.V11, [servedModel, localModel], new Set([servedModel.unique_id]));
-        const servedMessage = result.invalid[0].errors[0].message;
-        const localMessage = result.invalid[1].errors[0].message;
-        expect(servedMessage).toContain('The served manifest is outdated.');
-        expect(servedMessage).toContain('Redeploy the Lightdash project, then try again.');
-        expect(servedMessage).not.toContain('Update this field in your dbt model');
-        expect(localMessage).toContain('Update this field in your dbt model');
-    });
-    test('keeps valid v12 models when column config metadata is invalid', async () => {
-        const validModel = makeModel('valid_orders');
-        const invalidModel = {
-            ...makeModel('invalid_orders'),
-            columns: {
-                amount: {
-                    name: 'amount',
-                    config: {
-                        meta: {
-                            metrics: {
-                                total_amount: {
-                                    type: 'sum',
-                                    default_time_dimension: {
-                                        field: { created_at: null },
-                                        interval: 'DAY',
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-        const result = await (0, validation_2.validateDbtModel)('postgres', common_1.DbtManifestVersion.V12, [validModel, invalidModel]);
-        expect(result.valid.map(({ name }) => name)).toEqual(['valid_orders']);
-        expect(result.invalid).toMatchObject([
-            {
-                name: 'invalid_orders',
-                errors: [{ type: common_1.InlineErrorType.METADATA_PARSE_ERROR }],
-            },
-        ]);
-    });
-});

package/dist/handlers/apps/appCodeFiles.test.d.ts

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

package/dist/handlers/apps/appCodeFiles.test.d.ts.map

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