@lightdash/warehouses 2.228.1 → 2.229.0

package/dist/warehouseClients/BigqueryWarehouseClient.mock.js

@@ -1,130 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJobResponse = exports.rows = exports.getTableResponse = exports.credentials = void 0;
-const bigquery_1 = require("@google-cloud/bigquery");
-const common_1 = require("@lightdash/common");
-const stream_1 = require("stream");
-const BigqueryWarehouseClient_1 = require("./BigqueryWarehouseClient");
-exports.credentials = {
-    type: common_1.WarehouseTypes.BIGQUERY,
-    project: 'myDatabase',
-    dataset: '',
-    timeoutSeconds: 0,
-    priority: 'interactive',
-    keyfileContents: {},
-    retries: 0,
-    location: '',
-    maximumBytesBilled: 0,
-};
-const metadata = {
-    schema: {
-        fields: [
-            {
-                name: 'myStringColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.STRING,
-            },
-            {
-                name: 'myNumberColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.NUMERIC,
-            },
-            {
-                name: 'myBigNumberColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.BIGNUMERIC,
-            },
-            {
-                name: 'myDateColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.DATE,
-            },
-            {
-                name: 'myTimestampColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.TIMESTAMP,
-            },
-            {
-                name: 'myBooleanColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.BOOLEAN,
-            },
-            {
-                name: 'myArrayColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.ARRAY,
-            },
-            {
-                name: 'myObjectColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.STRUCT,
-            },
-            {
-                name: 'myRepeatedColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.STRING,
-                mode: 'REPEATED',
-            },
-            {
-                name: 'myRecordColumn',
-                type: BigqueryWarehouseClient_1.BigqueryFieldType.RECORD,
-                mode: 'NULLABLE',
-                fields: [
-                    { name: 'id', type: BigqueryWarehouseClient_1.BigqueryFieldType.INT64 },
-                    { name: 'createdAt', type: BigqueryWarehouseClient_1.BigqueryFieldType.TIMESTAMP },
-                    {
-                        name: 'tags',
-                        type: BigqueryWarehouseClient_1.BigqueryFieldType.RECORD,
-                        mode: 'REPEATED',
-                        fields: [
-                            { name: 'label', type: BigqueryWarehouseClient_1.BigqueryFieldType.STRING },
-                        ],
-                    },
-                ],
-            },
-        ],
-    },
-};
-exports.getTableResponse = {
-    id: 'myTable',
-    bigQuery: { projectId: 'myDatabase' },
-    getMetadata: vi.fn(() => [metadata]),
-};
-// eslint-disable-next-line no-underscore-dangle
-const [bigqueryDecimalValues] = bigquery_1.BigQuery.mergeSchemaWithRows_({
-    fields: [
-        {
-            name: 'myNumberColumn',
-            type: BigqueryWarehouseClient_1.BigqueryFieldType.NUMERIC,
-        },
-        {
-            name: 'myBigNumberColumn',
-            type: BigqueryWarehouseClient_1.BigqueryFieldType.BIGNUMERIC,
-        },
-    ],
-}, [
-    {
-        f: [{ v: '100.25' }, { v: '200.5' }],
-    },
-], { wrapIntegers: false });
-exports.rows = [
-    {
-        myStringColumn: 'string value',
-        ...bigqueryDecimalValues,
-        myDateColumn: new bigquery_1.BigQueryDate('2021-03-10'),
-        myTimestampColumn: new bigquery_1.BigQueryTimestamp('1990-03-02T08:30:00.010Z'),
-        myBooleanColumn: false,
-        myArrayColumn: ['1', '2', '3'],
-        myObjectColumn: { test: '1', toFixed: () => '123' },
-        myRepeatedColumn: ['a', 'b'],
-        myRecordColumn: {
-            id: 7,
-            createdAt: new bigquery_1.BigQueryTimestamp('1990-03-02T08:30:00.010Z'),
-            tags: [{ label: 'x' }, { label: 'y' }],
-        },
-    },
-];
-const mockStreamRow = () => new stream_1.Readable({
-    objectMode: true,
-    read() {
-        exports.rows.forEach((row) => this.push(row));
-        this.push(null);
-    },
-});
-exports.createJobResponse = [
-    {
-        getQueryResults: vi.fn(() => [exports.rows, undefined, metadata]),
-        getQueryResultsStream: vi.fn(mockStreamRow),
-    },
-];

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

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

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

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

package/dist/warehouseClients/BigqueryWarehouseClient.test.js

@@ -1,493 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const bigquery_1 = require("@google-cloud/bigquery");
-const common_1 = require("@lightdash/common");
-const BigqueryWarehouseClient_1 = require("./BigqueryWarehouseClient");
-const BigqueryWarehouseClient_mock_1 = require("./BigqueryWarehouseClient.mock");
-const WarehouseClient_mock_1 = require("./WarehouseClient.mock");
-describe('BigqueryWarehouseClient', () => {
-    it('expect query rows with mapped values', async () => {
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(BigqueryWarehouseClient_mock_1.credentials);
-        warehouse.client.createQueryJob = vi.fn(() => BigqueryWarehouseClient_mock_1.createJobResponse);
-        const results = await warehouse.runQuery('fake sql');
-        expect(results.fields).toEqual({
-            ...WarehouseClient_mock_1.expectedFields,
-            // NUMERIC is (38, 9) unless declared; BIGNUMERIC reports no kind
-            myNumberColumn: {
-                type: 'number',
-                numericKind: { kind: 'decimal', scale: 9 },
-            },
-            myBigNumberColumn: { type: 'number' },
-            myRepeatedColumn: { type: 'string' },
-            myRecordColumn: { type: 'string' },
-        });
-        expect(results.rows[0]).toEqual({
-            ...WarehouseClient_mock_1.expectedRow,
-            myNumberColumn: 100.25,
-            myBigNumberColumn: 200.5,
-            // BigQuery serialises nested values as JSON; other clients pass them through
-            myArrayColumn: '["1","2","3"]',
-            myObjectColumn: '{"test":"1"}',
-            myRepeatedColumn: '["a","b"]',
-            myRecordColumn: '{"id":7,"createdAt":"1990-03-02T08:30:00.010Z","tags":[{"label":"x"},{"label":"y"}]}',
-        });
-        expect(warehouse.client.createQueryJob).toHaveBeenCalledTimes(1);
-    });
-    it('expect createQueryJob to set the time_zone connection property when a timezone is passed', async () => {
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(BigqueryWarehouseClient_mock_1.credentials);
-        warehouse.client.createQueryJob = vi.fn(() => BigqueryWarehouseClient_mock_1.createJobResponse);
-        await warehouse.runQuery('fake sql', undefined, 'Asia/Tokyo');
-        expect(warehouse.client.createQueryJob).toHaveBeenCalledWith(expect.objectContaining({
-            connectionProperties: [
-                { key: 'time_zone', value: 'Asia/Tokyo' },
-            ],
-        }));
-    });
-    it('expect createQueryJob to omit connection properties when no timezone is passed', async () => {
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(BigqueryWarehouseClient_mock_1.credentials);
-        warehouse.client.createQueryJob = vi.fn(() => BigqueryWarehouseClient_mock_1.createJobResponse);
-        await warehouse.runQuery('fake sql');
-        expect(warehouse.client.createQueryJob).toHaveBeenCalledWith(expect.objectContaining({
-            connectionProperties: undefined,
-        }));
-    });
-    it('expect schema with bigquery types mapped to dimension types', async () => {
-        const getTableMock = vi
-            .fn()
-            .mockImplementationOnce(() => BigqueryWarehouseClient_mock_1.getTableResponse);
-        bigquery_1.Dataset.prototype.table = getTableMock;
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(BigqueryWarehouseClient_mock_1.credentials);
-        const expectedCatalog = structuredClone(WarehouseClient_mock_1.expectedWarehouseSchemaWithAwareTimestamp);
-        Object.assign(expectedCatalog.myDatabase.mySchema.myTable, {
-            myBigNumberColumn: common_1.DimensionType.NUMBER,
-            myRepeatedColumn: common_1.DimensionType.STRING,
-            myRecordColumn: common_1.DimensionType.STRING,
-            'myRecordColumn.id': common_1.DimensionType.NUMBER,
-            'myRecordColumn.createdAt': common_1.DimensionType.TIMESTAMP,
-            'myRecordColumn.tags': common_1.DimensionType.STRING,
-            'myRecordColumn.tags.label': common_1.DimensionType.STRING,
-        });
-        (0, common_1.setCatalogTimestampDomain)(expectedCatalog, 'myDatabase', 'mySchema', 'myTable', 'myRecordColumn.createdAt', 'aware');
-        const nestedShapes = {
-            myObjectColumn: { repeated: false, record: true },
-            myRepeatedColumn: { repeated: true, record: false },
-            myRecordColumn: { repeated: false, record: true },
-            'myRecordColumn.tags': { repeated: true, record: true },
-        };
-        Object.entries(nestedShapes).forEach(([path, shape]) => (0, common_1.setCatalogNestedColumnShape)(expectedCatalog, 'myDatabase', 'mySchema', 'myTable', path, shape));
-        expect(await warehouse.getCatalog(WarehouseClient_mock_1.config)).toEqual(expectedCatalog);
-        expect(getTableMock).toHaveBeenCalledTimes(1);
-        expect(BigqueryWarehouseClient_mock_1.getTableResponse.getMetadata).toHaveBeenCalledTimes(1);
-    });
-    it('expect getFields to flatten nested columns with the same shapes as getCatalog', async () => {
-        bigquery_1.Dataset.prototype.table = vi
-            .fn()
-            .mockImplementationOnce(() => BigqueryWarehouseClient_mock_1.getTableResponse);
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(BigqueryWarehouseClient_mock_1.credentials);
-        const fields = await warehouse.getFields('myTable', 'mySchema', 'myDatabase');
-        expect(fields.myDatabase.mySchema.myTable['myRecordColumn.id']).toBe(common_1.DimensionType.NUMBER);
-        expect((0, common_1.getCatalogNestedColumnShape)(fields, 'myDatabase', 'mySchema', 'myTable', 'myRecordColumn.tags')).toEqual({ repeated: true, record: true });
-        expect((0, common_1.getCatalogNestedColumnShape)(fields, 'myDatabase', 'mySchema', 'myTable', 'myStringColumn')).toBeUndefined();
-    });
-});
-describe('BigqueryWarehouseClient.getDatabases', () => {
-    const createDataset = (datasetId) => new bigquery_1.Dataset(new bigquery_1.BigQuery({ projectId: 'test-project' }), datasetId, {
-        location: 'EU',
-    });
-    const createClient = (datasets, query) => ({
-        getDatasets: vi
-            .fn()
-            .mockResolvedValue([datasets]),
-        query: vi.fn(query),
-    });
-    it('includes the stored size for each dataset', async () => {
-        const datasets = [createDataset('small'), createDataset('large')];
-        const queryMock = vi
-            .fn()
-            .mockResolvedValueOnce([[{ sizeBytes: 100 }]])
-            .mockResolvedValueOnce([[{ sizeBytes: 500 }]]);
-        const client = createClient(datasets, queryMock);
-        await expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.getDatabases('test-project', 'refresh-token', client)).resolves.toEqual([
-            {
-                projectId: 'test-project',
-                datasetId: 'small',
-                location: 'EU',
-                sizeBytes: 100,
-            },
-            {
-                projectId: 'test-project',
-                datasetId: 'large',
-                location: 'EU',
-                sizeBytes: 500,
-            },
-        ]);
-        expect(queryMock).toHaveBeenNthCalledWith(1, 'SELECT SUM(size_bytes) AS sizeBytes FROM `test-project.small.__TABLES__`');
-    });
-    it('returns null when an individual dataset size query fails', async () => {
-        const datasets = [createDataset('unavailable'), createDataset('ok')];
-        const queryMock = vi
-            .fn()
-            .mockRejectedValueOnce(new Error('permission denied'))
-            .mockResolvedValueOnce([[{ sizeBytes: 500 }]]);
-        const client = createClient(datasets, queryMock);
-        const result = await BigqueryWarehouseClient_1.BigqueryWarehouseClient.getDatabases('test-project', 'refresh-token', client);
-        expect(result.map(({ datasetId, sizeBytes }) => ({
-            datasetId,
-            sizeBytes,
-        }))).toEqual([
-            { datasetId: 'unavailable', sizeBytes: null },
-            { datasetId: 'ok', sizeBytes: 500 },
-        ]);
-    });
-    it('only queries sizes for the first 25 datasets', async () => {
-        const datasets = Array.from({ length: 30 }, (_, index) => createDataset(`dataset_${index}`));
-        const queryMock = vi
-            .fn()
-            .mockResolvedValue([[{ sizeBytes: 100 }]]);
-        const client = createClient(datasets, queryMock);
-        const result = await BigqueryWarehouseClient_1.BigqueryWarehouseClient.getDatabases('test-project', 'refresh-token', client);
-        expect(queryMock).toHaveBeenCalledTimes(25);
-        expect(result.slice(0, 25).every(({ sizeBytes }) => sizeBytes === 100)).toBe(true);
-        expect(result.slice(25).every(({ sizeBytes }) => sizeBytes === null)).toBe(true);
-    });
-});
-describe('BigqueryWarehouseClient.getProjectRecommendation', () => {
-    const createDataset = (projectId, datasetId, location) => new bigquery_1.Dataset(new bigquery_1.BigQuery({ projectId }), datasetId, {
-        location,
-    });
-    const createClient = (projectId, locations, queryImplementation) => {
-        const datasets = locations.map((location, index) => createDataset(projectId, `dataset_${index}`, location));
-        const getDatasets = vi.fn();
-        vi.mocked(getDatasets).mockResolvedValue([datasets]);
-        const query = vi.fn();
-        vi.mocked(query).mockImplementation(queryImplementation);
-        return { getDatasets, query };
-    };
-    it('ranks projects by their largest dataset across distinct regions', async () => {
-        const firstClient = createClient('first-project', ['EU', 'US', 'EU'], async ({ location }) => location === 'US'
-            ? [[{ table_schema: 'largest', total_bytes: 1200 }]]
-            : [[{ table_schema: 'smaller', total_bytes: 500 }]]);
-        const secondClient = createClient('second-project', ['EU'], async () => [
-            [
-                { table_schema: 'small', total_bytes: 100 },
-                { table_schema: 'large', total_bytes: 900 },
-            ],
-        ]);
-        const clients = new Map([
-            ['first-project', firstClient],
-            ['second-project', secondClient],
-        ]);
-        const clientFactory = vi.fn((projectId) => {
-            const client = clients.get(projectId);
-            if (!client)
-                throw new Error('Unexpected project');
-            return client;
-        });
-        const projects = [
-            { projectId: 'first-project', friendlyName: null },
-            { projectId: 'second-project', friendlyName: null },
-        ];
-        await expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.getProjectRecommendation(projects, 'refresh-token', clientFactory)).resolves.toEqual({ projectId: 'first-project' });
-        expect(vi.mocked(firstClient.getDatasets)).toHaveBeenCalledWith({
-            autoPaginate: false,
-            maxResults: 1000,
-        });
-        expect(vi.mocked(firstClient.query)).toHaveBeenCalledTimes(2);
-        expect(vi.mocked(firstClient.query)).toHaveBeenCalledWith({
-            query: 'SELECT table_schema, SUM(total_logical_bytes) AS total_bytes FROM `first-project`.`region-us`.INFORMATION_SCHEMA.TABLE_STORAGE GROUP BY table_schema',
-            location: 'US',
-        });
-    });
-    it('skips a project when any of its region queries errors', async () => {
-        const failingClient = createClient('failing-project', ['EU', 'US'], async ({ location }) => {
-            if (location === 'US')
-                throw new Error('permission denied');
-            return [[{ table_schema: 'largest', total_bytes: 5000 }]];
-        });
-        const healthyClient = createClient('healthy-project', ['EU'], async () => [[{ table_schema: 'available', total_bytes: 100 }]]);
-        const clients = new Map([
-            ['failing-project', failingClient],
-            ['healthy-project', healthyClient],
-        ]);
-        const clientFactory = vi.fn((projectId) => {
-            const client = clients.get(projectId);
-            if (!client)
-                throw new Error('Unexpected project');
-            return client;
-        });
-        await expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.getProjectRecommendation([
-            { projectId: 'failing-project', friendlyName: null },
-            { projectId: 'healthy-project', friendlyName: null },
-        ], 'refresh-token', clientFactory)).resolves.toEqual({ projectId: 'healthy-project' });
-    });
-    it('returns no recommendation when every project score is unavailable', async () => {
-        const client = createClient('unavailable-project', ['EU'], async () => {
-            throw new Error('permission denied');
-        });
-        const clientFactory = vi.fn();
-        vi.mocked(clientFactory).mockReturnValue(client);
-        await expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.getProjectRecommendation([{ projectId: 'unavailable-project', friendlyName: null }], 'refresh-token', clientFactory)).resolves.toEqual({ projectId: null });
-    });
-    it('caps ranking at eight projects and three regions per project', async () => {
-        const projects = Array.from({ length: 10 }, (_, index) => ({
-            projectId: `project-${index}`,
-            friendlyName: null,
-        }));
-        const clients = new Map(projects.map(({ projectId }, index) => [
-            projectId,
-            createClient(projectId, ['EU', 'US', 'asia-east1', 'us-west1'], async () => [
-                [{ table_schema: 'dataset', total_bytes: index }],
-            ]),
-        ]));
-        const clientFactory = vi.fn((projectId) => {
-            const client = clients.get(projectId);
-            if (!client)
-                throw new Error('Unexpected project');
-            return client;
-        });
-        await expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.getProjectRecommendation(projects, 'refresh-token', clientFactory)).resolves.toEqual({ projectId: 'project-7' });
-        expect(vi.mocked(clientFactory)).toHaveBeenCalledTimes(8);
-        projects.forEach(({ projectId }, index) => {
-            const client = clients.get(projectId);
-            if (!client)
-                throw new Error('Unexpected project');
-            expect(vi.mocked(client.getDatasets)).toHaveBeenCalledTimes(index < 8 ? 1 : 0);
-            expect(vi.mocked(client.query)).toHaveBeenCalledTimes(index < 8 ? 3 : 0);
-        });
-    });
-});
-describe('BigqueryWarehouseClient.sanitizeLabelsWithValues', () => {
-    let warnSpy;
-    beforeEach(() => {
-        warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        warnSpy.mockRestore();
-    });
-    it('returns undefined when given no labels', () => {
-        expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues(undefined)).toBeUndefined();
-    });
-    it('lowercases and normalises string values', () => {
-        expect(BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues({
-            Scheduler_Uuid: 'ABC-123',
-        })).toEqual({ scheduler_uuid: 'abc-123' });
-        expect(warnSpy).not.toHaveBeenCalled();
-    });
-    it('coerces numeric values without crashing and logs a warning', () => {
-        const result = BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues({
-            job_id: 224187,
-        });
-        expect(result).toEqual({ job_id: '224187' });
-        expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('coerced non-string tag value'), { key: 'job_id', valueType: 'number' });
-    });
-    it('replaces null/undefined with empty_value silently', () => {
-        const result = BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues({
-            scheduler_name: null,
-            saved_sql_uuid: undefined,
-        });
-        expect(result).toEqual({
-            scheduler_name: 'empty_value',
-            saved_sql_uuid: 'empty_value',
-        });
-        expect(warnSpy).not.toHaveBeenCalled();
-    });
-    it('coerces boolean values', () => {
-        const result = BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues({
-            embed: true,
-        });
-        expect(result).toEqual({ embed: 'true' });
-        expect(warnSpy).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({ valueType: 'boolean' }));
-    });
-    it('sanitizes user attribute query tags for BigQuery labels', () => {
-        const result = BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues({
-            'user_attribute_User Tier': 'Enterprise Customer/EMEA',
-            user_attribute_company: "O'Reilly Media",
-        });
-        expect(result).toEqual({
-            user_attribute_user_tier: 'enterprise_customer_emea',
-            user_attribute_company: 'o_reilly_media',
-        });
-        expect(warnSpy).not.toHaveBeenCalled();
-    });
-    it('limits labels to the BigQuery maximum', () => {
-        const labels = Object.fromEntries(Array.from({ length: 70 }, (_, index) => [
-            `user_attribute_${index}`,
-            `value_${index}`,
-        ]));
-        const result = BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues(labels);
-        expect(Object.keys(result ?? {})).toHaveLength(64);
-    });
-    it('keeps non-user-attribute labels when user attributes exceed the BigQuery maximum', () => {
-        const labels = {
-            ...Object.fromEntries(Array.from({ length: 70 }, (_, index) => [
-                `user_attribute_${index}`,
-                `value_${index}`,
-            ])),
-            query_uuid: 'query-uuid',
-        };
-        const result = BigqueryWarehouseClient_1.BigqueryWarehouseClient.sanitizeLabelsWithValues(labels);
-        expect(result).toEqual(expect.objectContaining({ query_uuid: 'query-uuid' }));
-        expect(Object.keys(result ?? {})).toHaveLength(64);
-    });
-});
-describe('BigquerySqlBuilder escaping', () => {
-    const bigquerySqlBuilder = new BigqueryWarehouseClient_1.BigquerySqlBuilder();
-    test('Should escape backslashes and quotes in bigquery', () => {
-        expect(bigquerySqlBuilder.escapeString("\\') OR (1=1) --")).toBe("\\\\\\') OR (1=1) ");
-    });
-    test('Should handle SQL injection attempts', () => {
-        // Test with a typical SQL injection pattern
-        const maliciousInput = "'; DROP TABLE users; --";
-        const escaped = bigquerySqlBuilder.escapeString(maliciousInput);
-        expect(escaped).toBe("\\'; DROP TABLE users; ");
-        // Test with another common SQL injection pattern
-        const anotherMaliciousInput = "' OR '1'='1";
-        const anotherEscaped = bigquerySqlBuilder.escapeString(anotherMaliciousInput);
-        expect(anotherEscaped).toBe("\\' OR \\'1\\'=\\'1");
-    });
-    test('Should NOT remove # comments from strings', () => {
-        // Test that # symbols are preserved in strings (not treated as comments)
-        const stringWithHash = 'Column name with # symbol';
-        const escaped = bigquerySqlBuilder.escapeString(stringWithHash);
-        expect(escaped).toBe('Column name with # symbol');
-        // Test that # at start of line is preserved
-        const hashAtStart = '#important-tag';
-        const escapedHashStart = bigquerySqlBuilder.escapeString(hashAtStart);
-        expect(escapedHashStart).toBe('#important-tag');
-        // Test multiple # symbols are preserved
-        const multipleHashes = 'value1#value2#value3';
-        const escapedMultiple = bigquerySqlBuilder.escapeString(multipleHashes);
-        expect(escapedMultiple).toBe('value1#value2#value3');
-    });
-    test('Should still remove -- and /* */ comments', () => {
-        // Test that -- comments are still removed
-        const stringWithDashComment = 'test value -- this is a comment';
-        const escapedDash = bigquerySqlBuilder.escapeString(stringWithDashComment);
-        expect(escapedDash).toBe('test value ');
-        // Test that /* */ comments are still removed
-        const stringWithBlockComment = 'test /* block comment */ value';
-        const escapedBlock = bigquerySqlBuilder.escapeString(stringWithBlockComment);
-        expect(escapedBlock).toBe('test  value');
-    });
-});
-describe('BigquerySqlBuilder temporal literals', () => {
-    // BigQuery refuses to COALESCE mixed DATE/DATETIME/TIMESTAMP, so each
-    // temporal kind needs its own literal.
-    const builder = new BigqueryWarehouseClient_1.BigquerySqlBuilder();
-    const epoch = new Date(0);
-    test('casts to an aware TIMESTAMP', () => {
-        expect(builder.castToTimestamp(epoch)).toBe("TIMESTAMP('1970-01-01T00:00:00.000Z')");
-    });
-    test('casts to a DATE literal', () => {
-        expect(builder.castToDate(epoch)).toBe("DATE '1970-01-01'");
-    });
-    test('casts to a zoneless DATETIME literal', () => {
-        expect(builder.castToNaiveTimestamp(epoch)).toBe("DATETIME '1970-01-01 00:00:00'");
-    });
-});
-describe('BigqueryWarehouseClient Google OAuth token errors', () => {
-    const createGaxiosError = (data, message = data.error, status = 400) => Object.assign(new Error(message), {
-        status,
-        response: { status, data },
-    });
-    const invalidGrant = {
-        error: 'invalid_grant',
-        error_description: 'Token has been expired or revoked.',
-        error_subtype: 'invalid_rapt',
-    };
-    const userCredentials = {
-        ...BigqueryWarehouseClient_mock_1.credentials,
-        authenticationType: common_1.BigqueryAuthenticationType.SSO,
-        keyfileContents: {
-            type: 'authorized_user',
-            client_id: 'client-id',
-            client_secret: 'client-secret',
-            refresh_token: 'refresh-token',
-        },
-    };
-    const serviceAccountCredentials = {
-        ...BigqueryWarehouseClient_mock_1.credentials,
-        authenticationType: common_1.BigqueryAuthenticationType.PRIVATE_KEY,
-        keyfileContents: {
-            type: 'service_account',
-            client_email: 'robot@example.iam.gserviceaccount.com',
-            private_key: 'private-key',
-        },
-    };
-    const createWarehouseRejectingQueries = (warehouseCredentials, error) => {
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(warehouseCredentials);
-        const createQueryJob = vi.fn();
-        vi.mocked(createQueryJob).mockRejectedValue(error);
-        warehouse.client.createQueryJob =
-            createQueryJob;
-        return warehouse;
-    };
-    const executeAsyncQuery = (warehouse) => warehouse.executeAsyncQuery({
-        sql: 'SELECT 1',
-        tags: {},
-    });
-    it('translates an invalid_grant rejection of a user keyfile into a BigqueryTokenError', async () => {
-        const warehouse = createWarehouseRejectingQueries(userCredentials, createGaxiosError(invalidGrant));
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow(common_1.BigqueryTokenError);
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow('Google rejected the BigQuery refresh token (invalid_grant: Token has been expired or revoked.; invalid_rapt). Reconnect your BigQuery account in personal settings.');
-    });
-    it('translates an invalid_grant rejection of a service account keyfile into a connection error', async () => {
-        const warehouse = createWarehouseRejectingQueries(serviceAccountCredentials, createGaxiosError(invalidGrant));
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow(common_1.WarehouseConnectionError);
-        await expect(executeAsyncQuery(warehouse)).rejects.not.toThrow(common_1.BigqueryTokenError);
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow('Google rejected the BigQuery credentials (invalid_grant: Token has been expired or revoked.; invalid_rapt).');
-    });
-    it('omits the subtype clause and falls back to invalid_grant alone', async () => {
-        const warehouse = createWarehouseRejectingQueries(userCredentials, createGaxiosError({ error: 'invalid_grant' }));
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow('Google rejected the BigQuery refresh token (invalid_grant). Reconnect your BigQuery account in personal settings.');
-    });
-    it('leaves other 400 responses untranslated', async () => {
-        const original = createGaxiosError({
-            error: 'invalid_request',
-            error_description: 'Missing required parameter: refresh_token',
-        });
-        const warehouse = createWarehouseRejectingQueries(userCredentials, original);
-        await expect(executeAsyncQuery(warehouse)).rejects.toBe(original);
-    });
-    it('detects invalid_grant from the response body, not the error message', async () => {
-        const warehouse = createWarehouseRejectingQueries(userCredentials, createGaxiosError(invalidGrant, 'Token has been expired or revoked.'));
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow(common_1.BigqueryTokenError);
-    });
-    it('leaves a bare invalid_grant error without a response untranslated', async () => {
-        const original = new Error('invalid_grant');
-        const warehouse = createWarehouseRejectingQueries(userCredentials, original);
-        await expect(executeAsyncQuery(warehouse)).rejects.toBe(original);
-    });
-    it('still translates structured BigQuery errors', async () => {
-        const warehouse = createWarehouseRejectingQueries(userCredentials, {
-            errors: [
-                {
-                    reason: 'quotaExceeded',
-                    message: 'Query exceeded the daily quota',
-                },
-            ],
-        });
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow(common_1.WarehouseQueryError);
-        await expect(executeAsyncQuery(warehouse)).rejects.toThrow('BigQuery quota exceeded. Query exceeded the daily quota');
-    });
-    it('translates an invalid_grant rejection raised while fetching table metadata', async () => {
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(userCredentials);
-        const getMetadata = vi.fn();
-        vi.mocked(getMetadata).mockRejectedValue(createGaxiosError(invalidGrant));
-        bigquery_1.Dataset.prototype.table = vi.fn(() => ({ getMetadata }));
-        await expect(warehouse.getFields('myTable', 'mySchema', 'myDatabase')).rejects.toThrow(common_1.BigqueryTokenError);
-        await expect(warehouse.getCatalog(WarehouseClient_mock_1.config)).rejects.toThrow(common_1.BigqueryTokenError);
-    });
-    it('translates an invalid_grant rejection raised while listing datasets', async () => {
-        const warehouse = new BigqueryWarehouseClient_1.BigqueryWarehouseClient(userCredentials);
-        const getDatasets = vi.fn();
-        vi.mocked(getDatasets).mockRejectedValue(createGaxiosError(invalidGrant));
-        warehouse.client.getDatasets =
-            getDatasets;
-        await expect(warehouse.getAllTables()).rejects.toThrow(common_1.BigqueryTokenError);
-    });
-    it('translates an invalid_grant rejection from the connection test', async () => {
-        const warehouse = createWarehouseRejectingQueries(userCredentials, createGaxiosError(invalidGrant));
-        await expect(warehouse.test()).rejects.toThrow(common_1.BigqueryTokenError);
-    });
-});

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

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

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

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