@lightdash/warehouses 2.228.1 → 2.229.1

package/dist/ssh/sshTunnelFailure.test.d.ts

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

package/dist/ssh/sshTunnelFailure.test.d.ts.map

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

package/dist/ssh/sshTunnelFailure.test.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const sshTunnelFailure_1 = require("./sshTunnelFailure");
-const err = (message, extra = {}) => Object.assign(new Error(message), extra);
-const before = { tcpConnected: false, handshakeCompleted: false };
-const afterTcp = { tcpConnected: true, handshakeCompleted: false };
-const afterHandshake = { tcpConnected: true, handshakeCompleted: true };
-(0, vitest_1.describe)('classifySshClientError', () => {
-    (0, vitest_1.it)('maps DNS failures to resolve', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('getaddrinfo ENOTFOUND bastion.example', {
-            code: 'ENOTFOUND',
-        }), before)).toBe('resolve');
-    });
-    (0, vitest_1.it)('maps anything before the TCP connect to tcp, including a dropped SYN', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('connect ETIMEDOUT 203.0.113.10:22 after 10000ms', {
-            code: 'ETIMEDOUT',
-        }), before)).toBe('tcp');
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('connect ECONNREFUSED 127.0.0.1:2222', {
-            code: 'ECONNREFUSED',
-        }), before)).toBe('tcp');
-    });
-    (0, vitest_1.it)('maps a ready timeout after the TCP connect to handshake', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('Timed out while waiting for handshake', {
-            level: 'client-timeout',
-        }), afterTcp)).toBe('handshake');
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('Connection lost before handshake', {
-            level: 'client-socket',
-        }), afterTcp)).toBe('handshake');
-    });
-    (0, vitest_1.it)('maps rejected keys to auth', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('All configured authentication methods failed', {
-            level: 'client-authentication',
-        }), afterHandshake)).toBe('auth');
-    });
-    (0, vitest_1.it)('treats a socket reset after the handshake as auth, not tcp', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.classifySshClientError)(err('read ECONNRESET', {
-            code: 'ECONNRESET',
-            level: 'client-socket',
-        }), afterHandshake)).toBe('auth');
-    });
-});
-(0, vitest_1.describe)('describeSshTunnelFailure', () => {
-    const base = {
-        sshHost: '203.0.113.10',
-        sshPort: 22,
-        sshUser: 'lightdash',
-        databaseHost: 'redshift.internal',
-        databasePort: 5439,
-        staticIp: '35.1.2.3',
-        cause: 'connect ETIMEDOUT',
-    };
-    (0, vitest_1.it)('tells the bastion admin which IP to allow on tcp failures', () => {
-        const message = (0, sshTunnelFailure_1.describeSshTunnelFailure)({ ...base, stage: 'tcp' });
-        (0, vitest_1.expect)(message).toContain('Could not reach 203.0.113.10 on port 22');
-        (0, vitest_1.expect)(message).toContain('from Lightdash (35.1.2.3)');
-        (0, vitest_1.expect)(message).toContain('Allow inbound SSH from 35.1.2.3');
-    });
-    (0, vitest_1.it)('omits the IP when the instance has none', () => {
-        const message = (0, sshTunnelFailure_1.describeSshTunnelFailure)({
-            ...base,
-            staticIp: null,
-            stage: 'tcp',
-        });
-        (0, vitest_1.expect)(message).not.toContain('35.1.2.3');
-        (0, vitest_1.expect)(message).toContain("Lightdash's IP");
-    });
-    (0, vitest_1.it)('names the user on auth failures', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.describeSshTunnelFailure)({ ...base, stage: 'auth' })).toContain('rejected the key for user "lightdash"');
-    });
-    (0, vitest_1.it)('names the database endpoint on forward failures', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.describeSshTunnelFailure)({ ...base, stage: 'forward' })).toContain('redshift.internal:5439');
-    });
-});
-(0, vitest_1.describe)('sshClientErrorMessage', () => {
-    (0, vitest_1.it)('unpacks the empty-message AggregateError Node emits for a refused port', () => {
-        const aggregate = err('', {
-            code: 'ECONNREFUSED',
-            errors: [
-                new Error('connect ECONNREFUSED ::1:2299'),
-                new Error('connect ECONNREFUSED 127.0.0.1:2299'),
-            ],
-        });
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.sshClientErrorMessage)(aggregate)).toBe('connect ECONNREFUSED ::1:2299; connect ECONNREFUSED 127.0.0.1:2299');
-    });
-    (0, vitest_1.it)('falls back to the code, then a fixed string', () => {
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.sshClientErrorMessage)(err('', { code: 'ETIMEDOUT' }))).toBe('ETIMEDOUT');
-        (0, vitest_1.expect)((0, sshTunnelFailure_1.sshClientErrorMessage)(err(''))).toBe('connection failed');
-    });
-});

package/dist/validateWarehouseColumnReferences.test.d.ts

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

package/dist/validateWarehouseColumnReferences.test.d.ts.map

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

package/dist/validateWarehouseColumnReferences.test.js

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const common_1 = require("@lightdash/common");
-const validateWarehouseColumnReferences_1 = require("./validateWarehouseColumnReferences");
-const explore = {
-    name: 'orders',
-    label: 'Orders',
-    tags: [],
-    baseTable: 'orders',
-    joinedTables: [],
-    targetDatabase: common_1.SupportedDbtAdapter.POSTGRES,
-    tables: {
-        orders: {
-            name: 'orders',
-            label: 'Orders',
-            database: 'postgres',
-            schema: 'jaffle',
-            sqlTable: '"postgres"."jaffle"."orders"',
-            lineageGraph: {},
-            dimensions: {
-                amount: {
-                    fieldType: common_1.FieldType.DIMENSION,
-                    type: common_1.DimensionType.NUMBER,
-                    name: 'amount',
-                    label: 'Amount',
-                    table: 'orders',
-                    tableLabel: 'Orders',
-                    // eslint-disable-next-line no-template-curly-in-string
-                    sql: '${TABLE}.amount',
-                    compiledSql: '"orders".amount',
-                    tablesReferences: ['orders'],
-                    hidden: false,
-                },
-            },
-            metrics: {
-                stale_metric: {
-                    fieldType: common_1.FieldType.METRIC,
-                    type: common_1.MetricType.AVERAGE,
-                    name: 'stale_metric',
-                    label: 'Stale metric',
-                    table: 'orders',
-                    tableLabel: 'Orders',
-                    // eslint-disable-next-line no-template-curly-in-string
-                    sql: '${TABLE}.rolling_30d_avg_sales',
-                    compiledSql: 'AVG("orders".rolling_30d_avg_sales)',
-                    tablesReferences: ['orders'],
-                    hidden: false,
-                },
-            },
-        },
-    },
-};
-const queryResult = { fields: {}, rows: [] };
-const tags = { query_context: 'cli' };
-describe('validateWarehouseColumnReferences', () => {
-    it('returns explores unchanged when the warehouse accepts all references', async () => {
-        const runQuery = vi.fn(async () => queryResult);
-        const result = await (0, validateWarehouseColumnReferences_1.validateWarehouseColumnReferences)({
-            explores: [explore],
-            client: { getFieldQuoteChar: () => '"', runQuery },
-            tags,
-        });
-        expect(result).toEqual([explore]);
-        expect(runQuery).toHaveBeenCalledTimes(1);
-        expect(runQuery).toHaveBeenNthCalledWith(1, 'SELECT "orders".amount, "orders".rolling_30d_avg_sales FROM "postgres"."jaffle"."orders" AS "orders" WHERE 1 = 0', tags);
-    });
-    it('attaches one warning for each reference rejected by the warehouse', async () => {
-        const runQuery = vi.fn(async (sql) => {
-            if (sql.includes('rolling_30d_avg_sales')) {
-                throw new Error('column orders.rolling_30d_avg_sales does not exist');
-            }
-            return queryResult;
-        });
-        const [result] = await (0, validateWarehouseColumnReferences_1.validateWarehouseColumnReferences)({
-            explores: [explore],
-            client: { getFieldQuoteChar: () => '"', runQuery },
-            tags,
-        });
-        expect(result).toEqual({
-            ...explore,
-            warnings: [
-                {
-                    type: common_1.InlineErrorType.WAREHOUSE_COLUMN_ERROR,
-                    message: 
-                    // eslint-disable-next-line no-template-curly-in-string
-                    'Warehouse rejected column reference ${TABLE}.rolling_30d_avg_sales in model "orders": column orders.rolling_30d_avg_sales does not exist',
-                },
-            ],
-        });
-        expect(runQuery).toHaveBeenCalledTimes(5);
-    });
-    it('skips column validation when the relation probe fails', async () => {
-        const runQuery = vi.fn(async () => {
-            throw new Error('warehouse unavailable');
-        });
-        const result = await (0, validateWarehouseColumnReferences_1.validateWarehouseColumnReferences)({
-            explores: [explore],
-            client: { getFieldQuoteChar: () => '"', runQuery },
-            tags,
-        });
-        expect(result).toEqual([explore]);
-        expect(runQuery).toHaveBeenCalledTimes(2);
-    });
-    it('preserves pre-existing warnings and appends warehouse warnings after them', async () => {
-        const existingWarning = {
-            type: common_1.InlineErrorType.FIELD_ERROR,
-            message: 'Dimension "broken_dimension" failed to compile',
-        };
-        const exploreWithExistingWarning = {
-            ...explore,
-            warnings: [existingWarning],
-        };
-        const runQuery = vi.fn(async (sql) => {
-            if (sql.includes('rolling_30d_avg_sales')) {
-                throw new Error('column orders.rolling_30d_avg_sales does not exist');
-            }
-            return queryResult;
-        });
-        const [result] = await (0, validateWarehouseColumnReferences_1.validateWarehouseColumnReferences)({
-            explores: [exploreWithExistingWarning],
-            client: { getFieldQuoteChar: () => '"', runQuery },
-            tags,
-        });
-        expect(result).toEqual({
-            ...exploreWithExistingWarning,
-            warnings: [
-                existingWarning,
-                {
-                    type: common_1.InlineErrorType.WAREHOUSE_COLUMN_ERROR,
-                    message: 
-                    // eslint-disable-next-line no-template-curly-in-string
-                    'Warehouse rejected column reference ${TABLE}.rolling_30d_avg_sales in model "orders": column orders.rolling_30d_avg_sales does not exist',
-                },
-            ],
-        });
-    });
-    it('skips explore errors and templated table references without probing', async () => {
-        const exploreError = {
-            name: 'broken_explore',
-            label: 'Broken explore',
-            errors: [
-                {
-                    type: common_1.InlineErrorType.METADATA_PARSE_ERROR,
-                    message: 'Failed to compile explore',
-                },
-            ],
-        };
-        const templatedExplore = {
-            ...explore,
-            name: 'templated_orders',
-            tables: {
-                orders: {
-                    ...explore.tables.orders,
-                    // eslint-disable-next-line no-template-curly-in-string
-                    sqlTable: '"postgres"."${ld.schema}"."orders"',
-                },
-            },
-        };
-        const runQuery = vi.fn(async () => queryResult);
-        const result = await (0, validateWarehouseColumnReferences_1.validateWarehouseColumnReferences)({
-            explores: [exploreError, templatedExplore],
-            client: { getFieldQuoteChar: () => '"', runQuery },
-            tags,
-        });
-        expect(result).toEqual([exploreError, templatedExplore]);
-        expect(runQuery).not.toHaveBeenCalled();
-    });
-});

package/dist/warehouseClients/AthenaWarehouseClient.test.d.ts

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

package/dist/warehouseClients/AthenaWarehouseClient.test.d.ts.map

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

package/dist/warehouseClients/AthenaWarehouseClient.test.js

@@ -1,261 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable prefer-arrow-callback, func-names */
-const common_1 = require("@lightdash/common");
-const { mockAthenaClient } = vi.hoisted(() => ({
-    mockAthenaClient: vi.fn(),
-}));
-vi.mock('@aws-sdk/client-athena', async () => ({
-    ...(await vi.importActual('@aws-sdk/client-athena')),
-    AthenaClient: mockAthenaClient,
-}));
-const { mockFromTemporaryCredentials } = vi.hoisted(() => ({
-    mockFromTemporaryCredentials: vi.fn(() => 'sts-credentials'),
-}));
-vi.mock('@aws-sdk/credential-providers', () => ({
-    fromTemporaryCredentials: mockFromTemporaryCredentials,
-}));
-// eslint-disable-next-line import/first -- Must import after mocks are set up
-const AthenaWarehouseClient_1 = require("./AthenaWarehouseClient");
-const baseCredentials = {
-    type: common_1.WarehouseTypes.ATHENA,
-    region: 'us-east-1',
-    database: 'AwsDataCatalog',
-    schema: 'my_database',
-    s3StagingDir: 's3://bucket/staging/',
-    authenticationType: common_1.AthenaAuthenticationType.ACCESS_KEY,
-    accessKeyId: 'AKID',
-    secretAccessKey: 'SECRET',
-};
-describe('convertDataTypeToDimensionType', () => {
-    test.each([
-        [AthenaWarehouseClient_1.AthenaTypes.FLOAT, common_1.DimensionType.NUMBER],
-        ['FLOAT', common_1.DimensionType.NUMBER],
-        [AthenaWarehouseClient_1.AthenaTypes.DOUBLE, common_1.DimensionType.NUMBER],
-        [AthenaWarehouseClient_1.AthenaTypes.BIGINT, common_1.DimensionType.NUMBER],
-        ['decimal(10, 2)', common_1.DimensionType.NUMBER],
-    ])('maps Athena %s columns to %s dimensions', (input, expected) => {
-        expect((0, AthenaWarehouseClient_1.convertDataTypeToDimensionType)(input)).toBe(expected);
-    });
-});
-describe('AthenaWarehouseClient', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockAthenaClient.mockImplementation(function () {
-            return {};
-        });
-    });
-    describe('authentication', () => {
-        test('should use static credentials for ACCESS_KEY auth', () => {
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            expect(mockAthenaClient).toHaveBeenCalledWith({
-                region: 'us-east-1',
-                credentials: {
-                    accessKeyId: 'AKID',
-                    secretAccessKey: 'SECRET',
-                },
-            });
-        });
-        test('should forward sessionToken for temporary STS credentials', () => {
-            const creds = {
-                ...baseCredentials,
-                accessKeyId: 'ASIATEST',
-                secretAccessKey: 'SECRET',
-                sessionToken: 'SESSIONTOKEN',
-            };
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(creds);
-            expect(mockAthenaClient).toHaveBeenCalledWith({
-                region: 'us-east-1',
-                credentials: {
-                    accessKeyId: 'ASIATEST',
-                    secretAccessKey: 'SECRET',
-                    sessionToken: 'SESSIONTOKEN',
-                },
-            });
-        });
-        test('should not set credentials for IAM_ROLE auth', () => {
-            const creds = {
-                ...baseCredentials,
-                authenticationType: common_1.AthenaAuthenticationType.IAM_ROLE,
-            };
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(creds);
-            expect(mockAthenaClient).toHaveBeenCalledWith({
-                region: 'us-east-1',
-            });
-        });
-    });
-    describe('assume role', () => {
-        test('should wrap credentials with fromTemporaryCredentials when assumeRoleArn is set', () => {
-            const creds = {
-                ...baseCredentials,
-                assumeRoleArn: 'arn:aws:iam::123456789012:role/my-role',
-                assumeRoleExternalId: 'ext-id',
-            };
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(creds);
-            expect(mockFromTemporaryCredentials).toHaveBeenCalledWith({
-                masterCredentials: {
-                    accessKeyId: 'AKID',
-                    secretAccessKey: 'SECRET',
-                },
-                params: {
-                    RoleArn: 'arn:aws:iam::123456789012:role/my-role',
-                    RoleSessionName: 'lightdash-athena-session',
-                    ExternalId: 'ext-id',
-                },
-            });
-            expect(mockAthenaClient).toHaveBeenCalledWith({
-                region: 'us-east-1',
-                credentials: 'sts-credentials',
-            });
-        });
-        test('should chain assume role using temporary credentials (sessionToken in masterCredentials)', () => {
-            const creds = {
-                ...baseCredentials,
-                accessKeyId: 'ASIATEST',
-                secretAccessKey: 'SECRET',
-                sessionToken: 'SESSIONTOKEN',
-                assumeRoleArn: 'arn:aws:iam::123456789012:role/my-role',
-            };
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(creds);
-            expect(mockFromTemporaryCredentials).toHaveBeenCalledWith({
-                masterCredentials: {
-                    accessKeyId: 'ASIATEST',
-                    secretAccessKey: 'SECRET',
-                    sessionToken: 'SESSIONTOKEN',
-                },
-                params: {
-                    RoleArn: 'arn:aws:iam::123456789012:role/my-role',
-                    RoleSessionName: 'lightdash-athena-session',
-                    ExternalId: undefined,
-                },
-            });
-        });
-        test('should not wrap credentials when assumeRoleArn is not set', () => {
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            expect(mockFromTemporaryCredentials).not.toHaveBeenCalled();
-        });
-        test('should work with IAM_ROLE and assume role together', () => {
-            const creds = {
-                ...baseCredentials,
-                authenticationType: common_1.AthenaAuthenticationType.IAM_ROLE,
-                assumeRoleArn: 'arn:aws:iam::123456789012:role/my-role',
-            };
-            // eslint-disable-next-line no-new
-            new AthenaWarehouseClient_1.AthenaWarehouseClient(creds);
-            expect(mockFromTemporaryCredentials).toHaveBeenCalledWith({
-                masterCredentials: undefined,
-                params: {
-                    RoleArn: 'arn:aws:iam::123456789012:role/my-role',
-                    RoleSessionName: 'lightdash-athena-session',
-                    ExternalId: undefined,
-                },
-            });
-            expect(mockAthenaClient).toHaveBeenCalledWith({
-                region: 'us-east-1',
-                credentials: 'sts-credentials',
-            });
-        });
-    });
-    describe('error translation', () => {
-        // Synthesizes an error with the shape produced by the AWS SDK:
-        // an Error subclass whose `name` is the AWS error code, with optional
-        // $metadata.httpStatusCode (set by the SDK on every ServiceException).
-        const makeAwsError = (name, message, httpStatusCode) => {
-            const err = new Error(message);
-            err.name = name;
-            if (httpStatusCode !== undefined) {
-                err.$metadata = { httpStatusCode };
-            }
-            return err;
-        };
-        const setMockSendToReject = (error) => {
-            mockAthenaClient.mockImplementation(function () {
-                return { send: vi.fn().mockRejectedValue(error) };
-            });
-        };
-        test('translates UnrecognizedClientException into WarehouseConnectionError with hint', async () => {
-            setMockSendToReject(makeAwsError('UnrecognizedClientException', 'The security token included in the request is invalid.'));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseConnectionError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('[UnrecognizedClientException]'),
-            });
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('AWS rejected the access key ID'),
-            });
-        });
-        test('translates InvalidSignatureException into WarehouseConnectionError', async () => {
-            setMockSendToReject(makeAwsError('InvalidSignatureException', 'Signature does not match.'));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseConnectionError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('secret access key'),
-            });
-        });
-        test('translates ExpiredTokenException into WarehouseConnectionError', async () => {
-            setMockSendToReject(makeAwsError('ExpiredTokenException', 'The security token has expired.'));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseConnectionError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('expired'),
-            });
-        });
-        test('translates CredentialsProviderError into WarehouseConnectionError', async () => {
-            setMockSendToReject(makeAwsError('CredentialsProviderError', 'Could not load credentials from any providers'));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseConnectionError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('IAM Role'),
-            });
-        });
-        test('keeps non-auth errors as WarehouseQueryError from streamQuery', async () => {
-            setMockSendToReject(makeAwsError('InvalidRequestException', 'Workgroup primary not found'));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseQueryError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('[InvalidRequestException]'),
-            });
-        });
-        test('falls back to httpStatusCode=401 when error name is unfamiliar', async () => {
-            // Some AWS error variants don't show up in our known-name set but
-            // are still authentication failures (e.g. credential-provider chain
-            // wrapping). HTTP 401 alone should be enough to classify as a
-            // connection error.
-            setMockSendToReject(makeAwsError('SomeFutureAwsAuthError', 'unauthenticated', 401));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseConnectionError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('[SomeFutureAwsAuthError 401]'),
-            });
-        });
-        test('does NOT promote httpStatusCode=403 to a connection error (could be IAM gap)', async () => {
-            // AccessDeniedException is 403 but represents an IAM permission
-            // gap during a query — it should remain WarehouseQueryError when
-            // streamQuery is the caller. The catalog/tables/fields paths
-            // explicitly opt into 'connection' default elsewhere.
-            setMockSendToReject(makeAwsError('AccessDeniedException', 'You are not authorized to perform: athena:GetQueryResults', 403));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.test()).rejects.toBeInstanceOf(common_1.WarehouseQueryError);
-            await expect(client.test()).rejects.toMatchObject({
-                message: expect.stringContaining('[AccessDeniedException 403]'),
-            });
-        });
-        test('catalog/tables/fields default to WarehouseConnectionError', async () => {
-            setMockSendToReject(makeAwsError('AccessDeniedException', 'You are not authorized to perform: athena:ListTableMetadata'));
-            const client = new AthenaWarehouseClient_1.AthenaWarehouseClient(baseCredentials);
-            await expect(client.getAllTables()).rejects.toBeInstanceOf(common_1.WarehouseConnectionError);
-            await expect(client.getAllTables()).rejects.toMatchObject({
-                message: expect.stringContaining('[AccessDeniedException]'),
-            });
-            await expect(client.getAllTables()).rejects.toMatchObject({
-                message: expect.stringContaining('Failed to list tables'),
-            });
-        });
-    });
-});

package/dist/warehouseClients/BigqueryWarehouseClient.mock.d.ts

@@ -1,83 +0,0 @@
-import { AnyType, CreateBigqueryCredentials } from '@lightdash/common';
-import { Readable } from 'stream';
-import { BigqueryFieldType } from './BigqueryWarehouseClient';
-export declare const credentials: CreateBigqueryCredentials;
-export declare const getTableResponse: {
-    id: string;
-    bigQuery: {
-        projectId: string;
-    };
-    getMetadata: import("vitest").Mock<() => {
-        schema: {
-            fields: ({
-                name: string;
-                type: BigqueryFieldType;
-                mode?: undefined;
-                fields?: undefined;
-            } | {
-                name: string;
-                type: BigqueryFieldType;
-                mode: string;
-                fields?: undefined;
-            } | {
-                name: string;
-                type: BigqueryFieldType;
-                mode: string;
-                fields: ({
-                    mode?: undefined;
-                    fields?: undefined;
-                    name: string;
-                    type: BigqueryFieldType;
-                } | {
-                    name: string;
-                    type: BigqueryFieldType;
-                    mode: string;
-                    fields: {
-                        name: string;
-                        type: BigqueryFieldType;
-                    }[];
-                })[];
-            })[];
-        };
-    }[]>;
-};
-export declare const rows: Record<string, AnyType>[];
-declare const mockStreamRow: () => Readable;
-export declare const createJobResponse: {
-    getQueryResults: import("vitest").Mock<() => (Record<string, any>[] | {
-        schema: {
-            fields: ({
-                name: string;
-                type: BigqueryFieldType;
-                mode?: undefined;
-                fields?: undefined;
-            } | {
-                name: string;
-                type: BigqueryFieldType;
-                mode: string;
-                fields?: undefined;
-            } | {
-                name: string;
-                type: BigqueryFieldType;
-                mode: string;
-                fields: ({
-                    mode?: undefined;
-                    fields?: undefined;
-                    name: string;
-                    type: BigqueryFieldType;
-                } | {
-                    name: string;
-                    type: BigqueryFieldType;
-                    mode: string;
-                    fields: {
-                        name: string;
-                        type: BigqueryFieldType;
-                    }[];
-                })[];
-            })[];
-        };
-    } | undefined)[]>;
-    getQueryResultsStream: import("vitest").Mock<typeof mockStreamRow>;
-}[];
-export {};
-//# sourceMappingURL=BigqueryWarehouseClient.mock.d.ts.map

package/dist/warehouseClients/BigqueryWarehouseClient.mock.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BigqueryWarehouseClient.mock.d.ts","sourceRoot":"","sources":["../../src/warehouseClients/BigqueryWarehouseClient.mock.ts"],"names":[],"mappings":"AAKA,OAAO,EACH,OAAO,EACP,yBAAyB,EAE5B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAE9D,eAAO,MAAM,WAAW,EAAE,yBAUzB,CAAC;AA+DF,eAAO,MAAM,gBAAgB;IACzB,EAAE;IACF,QAAQ;QAAI,SAAS;;IACrB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CACd,CAAC;AAwBF,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAgBzC,CAAC;AAEF,QAAA,MAAM,aAAa,gBAOb,CAAC;AAEP,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAK7B,CAAC"}