@malloydata/db-bigquery 0.0.24-dev230224214106 → 0.0.24-dev230228224434

package/dist/bigquery.spec.js

@@ -51,119 +51,119 @@ const bigquery_1 = require("@google-cloud/bigquery");
 const util = __importStar(require("util"));
 const fs = __importStar(require("fs"));
 const url_1 = require("url");
-describe("db:BigQuery", () => {
+describe('db:BigQuery', () => {
     let bq;
     let runtime;
     beforeAll(() => {
-        bq = new bigquery_connection_1.BigQueryConnection("test");
+        bq = new bigquery_connection_1.BigQueryConnection('test');
         const files = {
-            "readURL": async (url) => {
+            readURL: async (url) => {
                 const filePath = (0, url_1.fileURLToPath)(url);
-                return await util.promisify(fs.readFile)(filePath, "utf8");
-            }
+                return await util.promisify(fs.readFile)(filePath, 'utf8');
+            },
         };
         runtime = new malloy.Runtime(files, bq);
     });
-    it("runs a SQL query", async () => {
-        const res = await bq.runSQL(`SELECT 1 as t`);
-        expect(res.rows[0]["t"]).toBe(1);
+    it('runs a SQL query', async () => {
+        const res = await bq.runSQL('SELECT 1 as t');
+        expect(res.rows[0]['t']).toBe(1);
     });
-    it("costs a SQL query", async () => {
-        const res = await bq.costQuery(`SELECT * FROM malloy-data.faa.airports`);
+    it('costs a SQL query', async () => {
+        const res = await bq.costQuery('SELECT * FROM malloy-data.faa.airports');
         expect(res).toBe(3029200);
     });
-    it("gets table schema", async () => {
-        const res = await bq.getTableFieldSchema(`malloy-data.faa.carriers`);
+    it('gets table schema', async () => {
+        const res = await bq.getTableFieldSchema('malloy-data.faa.carriers');
         expect(res.schema).toStrictEqual({
-            "fields": [
-                { "name": "code", "type": "STRING" },
-                { "name": "name", "type": "STRING" },
-                { "name": "nickname", "type": "STRING" }
-            ]
+            fields: [
+                { name: 'code', type: 'STRING' },
+                { name: 'name', type: 'STRING' },
+                { name: 'nickname', type: 'STRING' },
+            ],
         });
     });
-    it.todo("gets table structdefs");
-    it("runs a Malloy query", async () => {
+    it.todo('gets table structdefs');
+    it('runs a Malloy query', async () => {
         const sql = await runtime
             .loadModel("explore: carriers is table('malloy-data.faa.carriers') { measure: carrier_count is count() }")
-            .loadQuery("query: carriers -> { aggregate: carrier_count }")
+            .loadQuery('query: carriers -> { aggregate: carrier_count }')
             .getSQL();
         const res = await bq.runSQL(sql);
-        expect(res.rows[0]["carrier_count"]).toBe(21);
+        expect(res.rows[0]['carrier_count']).toBe(21);
     });
-    it("streams a Malloy query for download", async () => {
+    it('streams a Malloy query for download', async () => {
         const sql = await runtime
             .loadModel("explore: carriers is table('malloy-data.faa.carriers') { measure: carrier_count is count() }")
-            .loadQuery("query: carriers -> { group_by: name }")
+            .loadQuery('query: carriers -> { group_by: name }')
             .getSQL();
         const res = await bq.downloadMalloyQuery(sql);
-        return new Promise((resolve) => {
+        return new Promise(resolve => {
             let count = 0;
-            res.on("data", () => (count += 1));
-            res.on("end", () => {
+            res.on('data', () => (count += 1));
+            res.on('end', () => {
                 expect(count).toBe(21);
                 resolve(true);
             });
         });
     });
-    it("manifests a temporary table", async () => {
-        const fullTempTableName = await bq.manifestTemporaryTable("SELECT 1 as t");
-        const splitTableName = fullTempTableName.split(".");
+    it('manifests a temporary table', async () => {
+        const fullTempTableName = await bq.manifestTemporaryTable('SELECT 1 as t');
+        const splitTableName = fullTempTableName.split('.');
         const sdk = new bigquery_1.BigQuery();
         const dataset = sdk.dataset(splitTableName[1]);
         const table = dataset.table(splitTableName[2]);
         const exists = await table.exists();
         expect(exists).toBeTruthy();
     });
-    describe.skip("manifests permanent table", () => {
-        const datasetName = "test_malloy_test_dataset";
-        const tableName = "test_malloy_test_table";
+    describe.skip('manifests permanent table', () => {
+        const datasetName = 'test_malloy_test_dataset';
+        const tableName = 'test_malloy_test_table';
         const sdk = new bigquery_1.BigQuery();
         // delete entire dataset before each test and once tests are complete
         const deleteTestDataset = async () => {
             const dataset = sdk.dataset(datasetName);
             if ((await dataset.exists())[0]) {
                 await dataset.delete({
-                    "force": true
+                    force: true,
                 });
             }
         };
         beforeEach(deleteTestDataset);
         afterAll(deleteTestDataset);
-        it("throws if dataset does not exist and createDataset=false", async () => {
+        it('throws if dataset does not exist and createDataset=false', async () => {
             await expect(async () => {
-                await bq.manifestPermanentTable("SELECT 1 as t", datasetName, tableName, false, false);
+                await bq.manifestPermanentTable('SELECT 1 as t', datasetName, tableName, false, false);
             }).rejects.toThrowError(`Dataset ${datasetName} does not exist`);
         });
-        it("creates dataset if createDataset=true", async () => {
+        it('creates dataset if createDataset=true', async () => {
             // note - dataset does not exist b/c of beforeEach()
-            await bq.manifestPermanentTable("SELECT 1 as t", datasetName, tableName, false, true);
+            await bq.manifestPermanentTable('SELECT 1 as t', datasetName, tableName, false, true);
             const dataset = sdk.dataset(datasetName);
             const [exists] = await dataset.exists();
             expect(exists).toBeTruthy();
         });
-        it("throws if table exist and overwriteExistingTable=false", async () => {
+        it('throws if table exist and overwriteExistingTable=false', async () => {
             const newDatasetResponse = await sdk.createDataset(datasetName);
             const dataset = newDatasetResponse[0];
-            const tableMeta = { "name": tableName };
+            const tableMeta = { name: tableName };
             await dataset.createTable(tableName, tableMeta);
             await expect(async () => {
-                await bq.manifestPermanentTable("SELECT 1 as t", datasetName, tableName, false, true);
+                await bq.manifestPermanentTable('SELECT 1 as t', datasetName, tableName, false, true);
             }).rejects.toThrowError(`Table ${tableName} already exists`);
         });
-        it("manifests a table", async () => {
-            const jobId = await bq.manifestPermanentTable("SELECT 1 as t", datasetName, tableName, false, true);
+        it('manifests a table', async () => {
+            const jobId = await bq.manifestPermanentTable('SELECT 1 as t', datasetName, tableName, false, true);
             // wait for job to complete
             const [job] = await sdk.job(jobId).get();
             let [metaData] = await job.getMetadata();
-            while (metaData.status.state !== "DONE") {
-                await new Promise((resolve) => setTimeout(resolve, 1000));
+            while (metaData.status.state !== 'DONE') {
+                await new Promise(resolve => setTimeout(resolve, 1000));
                 [metaData] = await job.getMetadata();
             }
             // query the new table
             const [queryJob] = await sdk.createQueryJob(`SELECT * FROM ${datasetName}.${tableName}`);
             const [results] = await queryJob.getQueryResults();
-            expect(results[0]).toStrictEqual({ "t": 1 });
+            expect(results[0]).toStrictEqual({ t: 1 });
         });
     });
 });

package/dist/bigquery_connection.d.ts

@@ -1,7 +1,7 @@
-import { RowMetadata } from "@google-cloud/bigquery";
-import bigquery from "@google-cloud/bigquery/build/src/types";
-import { ResourceStream } from "@google-cloud/paginator";
-import { Connection, FieldTypeDef, MalloyQueryData, PersistSQLResults, PooledConnection, QueryData, QueryDataRow, SQLBlock, StreamingConnection, StructDef } from "@malloydata/malloy";
+import { RowMetadata } from '@google-cloud/bigquery';
+import bigquery from '@google-cloud/bigquery/build/src/types';
+import { ResourceStream } from '@google-cloud/paginator';
+import { Connection, FieldTypeDef, MalloyQueryData, PersistSQLResults, PooledConnection, QueryData, QueryDataRow, SQLBlock, StreamingConnection, StructDef } from '@malloydata/malloy';
 export interface BigQueryManagerOptions {
     credentials?: {
         clientId: string;

package/dist/bigquery_connection.js

@@ -57,7 +57,7 @@ const malloy_1 = require("@malloydata/malloy");
 class BigQueryAuthenticationError extends Error {
     constructor(message) {
         super(message);
-        this.name = "BigQueryAuthenticationError";
+        this.name = 'BigQueryAuthenticationError';
     }
 }
 exports.BigQueryAuthenticationError = BigQueryAuthenticationError;
@@ -66,7 +66,7 @@ const maybeRewriteError = (e) => {
     // the refresh token is invalid
     // ApiErrors happen if token is revoked (for example, client.revokeToken(creds.access_token!))
     if (e instanceof Error) {
-        if ((e instanceof gaxios_1.GaxiosError && e.code === "400") ||
+        if ((e instanceof gaxios_1.GaxiosError && e.code === '400') ||
             (e instanceof googleCommon.ApiError && e.code === 401)) {
             return new BigQueryAuthenticationError(e.message);
         }
@@ -93,18 +93,18 @@ class BigQueryConnection {
         this.schemaCache = new Map();
         this.sqlSchemaCache = new Map();
         this.bqToMalloyTypes = {
-            "DATE": { "type": "date" },
-            "STRING": { "type": "string" },
-            "INTEGER": { "type": "number", "numberType": "integer" },
-            "INT64": { "type": "number", "numberType": "integer" },
-            "FLOAT": { "type": "number", "numberType": "float" },
-            "FLOAT64": { "type": "number", "numberType": "float" },
-            "NUMERIC": { "type": "number", "numberType": "float" },
-            "BIGNUMERIC": { "type": "number", "numberType": "float" },
-            "TIMESTAMP": { "type": "timestamp" },
-            "BOOLEAN": { "type": "boolean" },
-            "BOOL": { "type": "boolean" },
-            "JSON": { "type": "json" }
+            DATE: { type: 'date' },
+            STRING: { type: 'string' },
+            INTEGER: { type: 'number', numberType: 'integer' },
+            INT64: { type: 'number', numberType: 'integer' },
+            FLOAT: { type: 'number', numberType: 'float' },
+            FLOAT64: { type: 'number', numberType: 'float' },
+            NUMERIC: { type: 'number', numberType: 'float' },
+            BIGNUMERIC: { type: 'number', numberType: 'float' },
+            TIMESTAMP: { type: 'timestamp' },
+            BOOLEAN: { type: 'boolean' },
+            BOOL: { type: 'boolean' },
+            JSON: { type: 'json' },
             // TODO (https://cloud.google.com/bigquery/docs/reference/rest/v2/tables#tablefieldschema):
             // BYTES
             // DATETIME
@@ -113,8 +113,8 @@ class BigQueryConnection {
         };
         this.name = name;
         this.bigQuery = new bigquery_1.BigQuery({
-            "userAgent": `Malloy/${malloy_1.Malloy.version}`,
-            "keyFilename": config.serviceAccountKeyPath
+            userAgent: `Malloy/${malloy_1.Malloy.version}`,
+            keyFilename: config.serviceAccountKeyPath,
         });
         // record project ID because for unclear reasons we have to modify the project ID on the SDK when
         // we want to use the tables API
@@ -122,10 +122,10 @@ class BigQueryConnection {
         this.defaultProject = config.defaultProject || this.bigQuery.projectId;
         this.queryOptions = queryOptions;
         this.config = config;
-        this.location = config.location || "US";
+        this.location = config.location || 'US';
     }
     get dialectName() {
-        return "standardsql";
+        return 'standardsql';
     }
     readQueryOptions() {
         const options = BigQueryConnection.DEFAULT_QUERY_OPTIONS;
@@ -156,19 +156,19 @@ class BigQueryConnection {
         const pageSize = (_a = options.rowLimit) !== null && _a !== void 0 ? _a : defaultOptions.rowLimit;
         try {
             const queryResultsOptions = {
-                "maxResults": pageSize,
-                "startIndex": rowIndex.toString()
+                maxResults: pageSize,
+                startIndex: rowIndex.toString(),
             };
             const jobResult = await this.createBigQueryJobAndGetResults(sqlCommand, undefined, queryResultsOptions);
             const totalRows = +(((_b = jobResult[2]) === null || _b === void 0 ? void 0 : _b.totalRows)
                 ? jobResult[2].totalRows
-                : "0");
+                : '0');
             // TODO need to probably surface the cause of the schema not present error
             if (((_c = jobResult[2]) === null || _c === void 0 ? void 0 : _c.schema) === undefined) {
-                throw new Error("Schema not present");
+                throw new Error('Schema not present');
             }
             // TODO even though we have 10 minute timeout limit, we still should confirm that resulting metadata has "jobComplete: true"
-            const data = { "rows": jobResult[0], totalRows };
+            const data = { rows: jobResult[0], totalRows };
             const schema = (_d = jobResult[2]) === null || _d === void 0 ? void 0 : _d.schema;
             return { data, schema };
         }
@@ -181,22 +181,22 @@ class BigQueryConnection {
         return data;
     }
     async runSQLBlockAndFetchResultSchema(sqlBlock, options) {
-        const { data, "schema": schemaRaw } = await this._runSQL(sqlBlock.selectStr, options);
+        const { data, schema: schemaRaw } = await this._runSQL(sqlBlock.selectStr, options);
         const schema = this.structDefFromSQLSchema(sqlBlock, schemaRaw);
         return { data, schema };
     }
     async downloadMalloyQuery(sqlCommand) {
         const job = await this.createBigQueryJob({
-            "query": sqlCommand
+            query: sqlCommand,
         });
         return job.getQueryResultsStream();
     }
     async dryRunSQLQuery(sqlCommand) {
         try {
             const [result] = await this.bigQuery.createQueryJob({
-                "location": this.location,
-                "query": sqlCommand,
-                "dryRun": true
+                location: this.location,
+                query: sqlCommand,
+                dryRun: true,
             });
             return result;
         }
@@ -215,8 +215,8 @@ class BigQueryConnection {
     }
     async getTableFieldSchema(tableURL) {
         var _a, _b;
-        const { "tablePath": tableName } = (0, malloy_1.parseTableURI)(tableURL);
-        const segments = tableName.split(".");
+        const { tablePath: tableName } = (0, malloy_1.parseTableURI)(tableURL);
+        const segments = tableName.split('.');
         // paths can have two or three segments
         // if there are only two segments, assume the dataset is "local" to the current billing project
         let projectId, datasetNamePart, tableNamePart;
@@ -241,9 +241,9 @@ class BigQueryConnection {
             this.bigQuery.projectId = this.projectId;
             const [metadata] = await metadataPromise;
             return {
-                "schema": metadata.schema,
-                "needsPartitionPsuedoColumn": ((_a = metadata.timePartitioning) === null || _a === void 0 ? void 0 : _a.type) !== undefined &&
-                    ((_b = metadata.timePartitioning) === null || _b === void 0 ? void 0 : _b.field) === undefined
+                schema: metadata.schema,
+                needsPartitionPsuedoColumn: ((_a = metadata.timePartitioning) === null || _a === void 0 ? void 0 : _a.type) !== undefined &&
+                    ((_b = metadata.timePartitioning) === null || _b === void 0 ? void 0 : _b.field) === undefined,
             };
         }
         catch (e) {
@@ -255,7 +255,7 @@ class BigQueryConnection {
         return result[0];
     }
     async test() {
-        await this.dryRunSQLQuery("SELECT 1");
+        await this.dryRunSQLQuery('SELECT 1');
     }
     /*
      *   Do we need to care about multiple overlapping calls to this function? No.
@@ -276,7 +276,7 @@ class BigQueryConnection {
      *
      */
     async manifestTemporaryTable(sqlCommand) {
-        const hash = crypto.createHash("md5").update(sqlCommand).digest("hex");
+        const hash = crypto.createHash('md5').update(sqlCommand).digest('hex');
         const tempTableName = this.temporaryTables.get(hash);
         if (tempTableName !== undefined) {
             return tempTableName;
@@ -284,16 +284,16 @@ class BigQueryConnection {
         else {
             try {
                 const [job] = await this.bigQuery.createQueryJob({
-                    "location": this.location,
-                    "query": sqlCommand
+                    location: this.location,
+                    query: sqlCommand,
                 });
                 let [metaData] = await job.getMetadata();
                 // wait for job to complete, because we need the table name
                 // TODO just because a job is "DONE" doesn't mean it ended correctly, should probably also confirm
                 // status is successful & that table was created
                 // TODO this needs better error handling and a timeout so that issues dont result in infinite looping
-                while (metaData.status.state !== "DONE") {
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                while (metaData.status.state !== 'DONE') {
+                    await new Promise(resolve => setTimeout(resolve, 1000));
                     [metaData] = await job.getMetadata();
                 }
                 // save table name
@@ -306,7 +306,7 @@ class BigQueryConnection {
                     return fullTableName;
                 }
                 else {
-                    throw new Error("bigquery.job.getMetadata() - metadata should have configuration but does not");
+                    throw new Error('bigquery.job.getMetadata() - metadata should have configuration but does not');
                 }
             }
             catch (e) {
@@ -332,9 +332,9 @@ class BigQueryConnection {
             throw new Error(`Table ${tableName} already exists`);
         }
         const [job] = await this.bigQuery.createQueryJob({
-            "query": sqlCommand,
-            "location": this.location,
-            "destination": table
+            query: sqlCommand,
+            location: this.location,
+            destination: table,
         });
         // if creating this job didn't throw, there's an ID.
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -348,44 +348,42 @@ class BigQueryConnection {
             const type = field.type;
             const name = field.name;
             // check for an array
-            if (field.mode === "REPEATED" && !["STRUCT", "RECORD"].includes(type)) {
+            if (field.mode === 'REPEATED' && !['STRUCT', 'RECORD'].includes(type)) {
                 const malloyType = this.bqToMalloyTypes[type];
                 if (malloyType) {
                     const innerStructDef = {
-                        "type": "struct",
+                        type: 'struct',
                         name,
-                        "dialect": this.dialectName,
-                        "structSource": { "type": "nested" },
-                        "structRelationship": {
-                            "type": "nested",
-                            "field": name,
-                            "isArray": true
+                        dialect: this.dialectName,
+                        structSource: { type: 'nested' },
+                        structRelationship: {
+                            type: 'nested',
+                            field: name,
+                            isArray: true,
                         },
-                        "fields": [{ ...malloyType, "name": "value" }]
+                        fields: [{ ...malloyType, name: 'value' }],
                     };
                     structDef.fields.push(innerStructDef);
                 }
             }
-            else if (["STRUCT", "RECORD"].includes(type)) {
+            else if (['STRUCT', 'RECORD'].includes(type)) {
                 const innerStructDef = {
-                    "type": "struct",
+                    type: 'struct',
                     name,
-                    "dialect": this.dialectName,
-                    "structSource": field.mode === "REPEATED"
-                        ? { "type": "nested" }
-                        : { "type": "inline" },
-                    "structRelationship": field.mode === "REPEATED"
-                        ? { "type": "nested", "field": name, "isArray": false }
-                        : { "type": "inline" },
-                    "fields": []
+                    dialect: this.dialectName,
+                    structSource: field.mode === 'REPEATED' ? { type: 'nested' } : { type: 'inline' },
+                    structRelationship: field.mode === 'REPEATED'
+                        ? { type: 'nested', field: name, isArray: false }
+                        : { type: 'inline' },
+                    fields: [],
                 };
                 this.addFieldsToStructDef(innerStructDef, field);
                 structDef.fields.push(innerStructDef);
             }
             else {
                 const malloyType = this.bqToMalloyTypes[type] || {
-                    "type": "unsupported",
-                    "rawType": type.toLowerCase()
+                    type: 'unsupported',
+                    rawType: type.toLowerCase(),
                 };
                 structDef.fields.push({ name, ...malloyType });
             }
@@ -393,7 +391,7 @@ class BigQueryConnection {
     }
     tableURLtoTablePath(tableURL) {
         const { tablePath } = (0, malloy_1.parseTableURI)(tableURL);
-        if (tablePath.split(".").length === 2) {
+        if (tablePath.split('.').length === 2) {
             return `${this.defaultProject}.${tablePath}`;
         }
         else {
@@ -402,43 +400,43 @@ class BigQueryConnection {
     }
     structDefFromTableSchema(tableURL, schemaInfo) {
         const structDef = {
-            "type": "struct",
-            "name": tableURL,
-            "dialect": this.dialectName,
-            "structSource": {
-                "type": "table",
-                "tablePath": this.tableURLtoTablePath(tableURL)
+            type: 'struct',
+            name: tableURL,
+            dialect: this.dialectName,
+            structSource: {
+                type: 'table',
+                tablePath: this.tableURLtoTablePath(tableURL),
             },
-            "structRelationship": {
-                "type": "basetable",
-                "connectionName": this.name
+            structRelationship: {
+                type: 'basetable',
+                connectionName: this.name,
             },
-            "fields": []
+            fields: [],
         };
         this.addFieldsToStructDef(structDef, schemaInfo.schema);
         if (schemaInfo.needsPartitionPsuedoColumn) {
             structDef.fields.push({
-                "type": "timestamp",
-                "name": "_PARTITIONTIME"
+                type: 'timestamp',
+                name: '_PARTITIONTIME',
             });
         }
         return structDef;
     }
     structDefFromSQLSchema(sqlBlock, tableFieldSchema) {
         const structDef = {
-            "type": "struct",
-            "name": sqlBlock.name,
-            "dialect": this.dialectName,
-            "structSource": {
-                "type": "sql",
-                "method": "subquery",
-                sqlBlock
+            type: 'struct',
+            name: sqlBlock.name,
+            dialect: this.dialectName,
+            structSource: {
+                type: 'sql',
+                method: 'subquery',
+                sqlBlock,
             },
-            "structRelationship": {
-                "type": "basetable",
-                "connectionName": this.name
+            structRelationship: {
+                type: 'basetable',
+                connectionName: this.name,
             },
-            "fields": []
+            fields: [],
         };
         this.addFieldsToStructDef(structDef, tableFieldSchema);
         return structDef;
@@ -452,12 +450,12 @@ class BigQueryConnection {
                 try {
                     const tableFieldSchema = await this.getTableFieldSchema(tableURL);
                     inCache = {
-                        "schema": this.structDefFromTableSchema(tableURL, tableFieldSchema)
+                        schema: this.structDefFromTableSchema(tableURL, tableFieldSchema),
                     };
                     this.schemaCache.set(tableURL, inCache);
                 }
                 catch (error) {
-                    inCache = { "error": error.message };
+                    inCache = { error: error.message };
                 }
             }
             if (inCache.schema !== undefined) {
@@ -479,9 +477,9 @@ class BigQueryConnection {
         for (let retries = 0; retries < 3; retries++) {
             try {
                 const [job] = await this.bigQuery.createQueryJob({
-                    "location": this.location,
-                    "query": sqlRef.selectStr,
-                    "dryRun": true
+                    location: this.location,
+                    query: sqlRef.selectStr,
+                    dryRun: true,
                 });
                 return job.metadata.statistics.query.schema;
             }
@@ -498,11 +496,11 @@ class BigQueryConnection {
             try {
                 const tableFieldSchema = await this.getSQLBlockSchema(sqlRef);
                 inCache = {
-                    "structDef": this.structDefFromSQLSchema(sqlRef, tableFieldSchema)
+                    structDef: this.structDefFromSQLSchema(sqlRef, tableFieldSchema),
                 };
             }
             catch (error) {
-                inCache = { "error": error.message };
+                inCache = { error: error.message };
             }
             this.sqlSchemaCache.set(key, inCache);
         }
@@ -514,8 +512,8 @@ class BigQueryConnection {
     async createBigQueryJobAndGetResults(sqlCommand, createQueryJobOptions, getQueryResultsOptions) {
         try {
             const job = await this.createBigQueryJob({
-                "query": sqlCommand,
-                ...createQueryJobOptions
+                query: sqlCommand,
+                ...createQueryJobOptions,
             });
             // TODO we should check if this is still required?
             // We do a simple retry-loop here, as a temporary fix for a transient
@@ -527,8 +525,8 @@ class BigQueryConnection {
             for (let retries = 0; retries < 3; retries++) {
                 try {
                     return await job.getQueryResults({
-                        "timeoutMs": 1000 * 60 * 2,
-                        ...getQueryResultsOptions
+                        timeoutMs: 1000 * 60 * 2,
+                        ...getQueryResultsOptions,
                     });
                 }
                 catch (fetchError) {
@@ -543,10 +541,10 @@ class BigQueryConnection {
     }
     async createBigQueryJob(createQueryJobOptions) {
         const [job] = await this.bigQuery.createQueryJob({
-            "location": this.location,
-            "maximumBytesBilled": this.config.maximumBytesBilled || MAXIMUM_BYTES_BILLED,
-            "jobTimeoutMs": Number(this.config.timeoutMs) || TIMEOUT_MS,
-            ...createQueryJobOptions
+            location: this.location,
+            maximumBytesBilled: this.config.maximumBytesBilled || MAXIMUM_BYTES_BILLED,
+            jobTimeoutMs: Number(this.config.timeoutMs) || TIMEOUT_MS,
+            ...createQueryJobOptions,
         });
         return job;
     }
@@ -563,9 +561,9 @@ class BigQueryConnection {
             }
             bigQuery
                 .createQueryStream(sqlCommand)
-                .on("error", onError)
-                .on("data", handleData)
-                .on("end", onEnd);
+                .on('error', onError)
+                .on('data', handleData)
+                .on('end', onEnd);
         }
         return (0, malloy_1.toAsyncGenerator)(streamBigQuery);
     }
@@ -575,6 +573,6 @@ class BigQueryConnection {
 }
 exports.BigQueryConnection = BigQueryConnection;
 BigQueryConnection.DEFAULT_QUERY_OPTIONS = {
-    "rowLimit": 10
+    rowLimit: 10,
 };
 //# sourceMappingURL=bigquery_connection.js.map

package/dist/index.d.ts

@@ -1 +1 @@
-export { BigQueryConnection } from "./bigquery_connection";
+export { BigQueryConnection } from './bigquery_connection';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-bigquery",
-  "version": "0.0.24-dev230224214106",
+  "version": "0.0.24-dev230228224434",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,9 @@
     "type": "git",
     "url": "https://github.com/malloydata/malloy"
   },
+  "engines": {
+    "node": ">=10"
+  },
   "scripts": {
     "lint": "eslint '**/*.ts{,x}'",
     "lint-fix": "eslint '**/*.ts{,x}' --fix",
@@ -21,7 +24,8 @@
   "dependencies": {
     "@google-cloud/bigquery": "^5.5.0",
     "@google-cloud/common": "^3.6.0",
-    "@malloydata/malloy": "^0.0.24-dev230224214106",
+    "@google-cloud/paginator": "^4.0.1",
+    "@malloydata/malloy": "^0.0.24-dev230228224434",
     "gaxios": "^4.2.0"
   }
 }