@malloydata/db-trino 0.0.195-dev241003204819 → 0.0.195-dev241007154000

package/dist/trino_connection.d.ts

@@ -1,4 +1,4 @@
-import { Connection, ConnectionConfig, FetchSchemaOptions, MalloyQueryData, FieldAtomicTypeDef, PersistSQLResults, QueryData, QueryOptionsReader, QueryRunStats, RunSQLOptions, SQLBlock, StructDef } from '@malloydata/malloy';
+import { Connection, ConnectionConfig, MalloyQueryData, PersistSQLResults, QueryData, QueryOptionsReader, QueryRunStats, RunSQLOptions, StructDef, TableSourceDef, SQLSourceDef, AtomicTypeDef } from '@malloydata/malloy';
 import { BaseConnection } from '@malloydata/malloy/connection';
 export interface TrinoManagerOptions {
     credentials?: {
@@ -30,15 +30,9 @@ export interface BaseRunner {
     }>;
 }
 export declare abstract class TrinoPrestoConnection extends BaseConnection implements Connection, PersistSQLResults {
-    trinoToMalloyTypes: {
-        [key: string]: FieldAtomicTypeDef;
-    };
-    private sqlToMalloyType;
     name: string;
     private readonly dialect;
     static DEFAULT_QUERY_OPTIONS: RunSQLOptions;
-    private schemaCache;
-    private sqlSchemaCache;
     private queryOptions?;
     private client;
     constructor(name: string, queryOptions?: QueryOptionsReader, pConfig?: TrinoConnectionConfiguration);
@@ -48,30 +42,19 @@ export declare abstract class TrinoPrestoConnection extends BaseConnection imple
     get supportsNesting(): boolean;
     manifestTemporaryTable(_sqlCommand: string): Promise<string>;
     unpackArray(data: unknown): unknown[];
-    convertRow(structDef: StructDef, _row: unknown): {};
-    convertNest(structDef: StructDef, _data: unknown): {};
+    convertRow(structDef: StructDef, rawRow: unknown): {};
+    convertNest(structDef: StructDef, _data: unknown): unknown[];
     runSQL(sqlCommand: string, options?: RunSQLOptions, _rowIndex?: number): Promise<MalloyQueryData>;
-    runSQLBlockAndFetchResultSchema(_sqlBlock: SQLBlock, _options?: RunSQLOptions): Promise<{
+    runSQLBlockAndFetchResultSchema(_sqlBlock: SQLSourceDef, _options?: RunSQLOptions): Promise<{
         data: MalloyQueryData;
         schema: StructDef;
     }>;
-    fetchSchemaForTables(missing: Record<string, string>, { refreshTimestamp }: FetchSchemaOptions): Promise<{
-        schemas: Record<string, StructDef>;
-        errors: Record<string, string>;
-    }>;
-    private structDefFromTableSchema;
-    fetchSchemaForSQLBlock(sqlRef: SQLBlock, { refreshTimestamp }: FetchSchemaOptions): Promise<{
-        structDef: StructDef;
-        error?: undefined;
-    } | {
-        error: string;
-        structDef?: undefined;
-    }>;
-    private structDefFromSqlBlock;
+    fetchTableSchema(tableKey: string, tablePath: string): Promise<TableSourceDef>;
+    fetchSelectSchema(sqlRef: SQLSourceDef): Promise<SQLSourceDef>;
     protected abstract fillStructDefForSqlBlockSchema(sql: string, structDef: StructDef): Promise<void>;
     protected executeAndWait(sqlBlock: string): Promise<void>;
     splitColumns(s: string): string[];
-    malloyTypeFromTrinoType(name: string, trinoType: string): FieldAtomicTypeDef | StructDef;
+    malloyTypeFromTrinoType(name: string, trinoType: string): AtomicTypeDef;
     structDefFromSchema(rows: string[][], structDef: StructDef): void;
     protected loadSchemaForSqlBlock(sqlBlock: string, structDef: StructDef, element: string): Promise<StructDef>;
     estimateQueryCost(_sqlCommand: string): Promise<QueryRunStats>;

package/dist/trino_connection.js

@@ -102,49 +102,10 @@ class TrinoRunner {
         return { rows: outputRows, columns };
     }
 }
-// manage access to BQ, control costs, enforce global data/API limits
 class TrinoPrestoConnection extends connection_1.BaseConnection {
-    sqlToMalloyType(sqlType) {
-        var _a, _b;
-        const baseSqlType = (_b = (_a = sqlType.match(/^(\w+)/)) === null || _a === void 0 ? void 0 : _a.at(0)) !== null && _b !== void 0 ? _b : sqlType;
-        if (this.trinoToMalloyTypes[baseSqlType]) {
-            return this.trinoToMalloyTypes[baseSqlType];
-        }
-        return undefined;
-    }
     constructor(name, queryOptions, pConfig) {
         super();
-        this.trinoToMalloyTypes = {
-            'varchar': { type: 'string' },
-            'integer': { type: 'number', numberType: 'integer' },
-            'bigint': { type: 'number', numberType: 'integer' },
-            'smallint': { type: 'number', numberType: 'integer' },
-            'tinyint': { type: 'number', numberType: 'integer' },
-            'double': { type: 'number', numberType: 'float' },
-            'decimal': { type: 'number', numberType: 'float' },
-            'string': { type: 'string' },
-            'date': { type: 'date' },
-            'timestamp': { type: 'timestamp' },
-            'boolean': { type: 'boolean' },
-            // TODO(figutierrez0): cleanup.
-            /* '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
-            // TIME
-            // GEOGRAPHY
-        };
-        this.dialect = new malloy_1.StandardSQLDialect();
-        this.schemaCache = new Map();
-        this.sqlSchemaCache = new Map();
+        this.dialect = new malloy_1.TrinoDialect();
         const config = pConfig || {};
         this.name = name;
         if (name === 'trino') {
@@ -185,22 +146,29 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
     unpackArray(data) {
         return data;
     }
-    convertRow(structDef, _row) {
+    convertRow(structDef, rawRow) {
+        var _a;
         const retRow = {};
-        const row = this.unpackArray(_row);
+        const row = this.unpackArray(rawRow);
         for (let i = 0; i < structDef.fields.length; i++) {
             const field = structDef.fields[i];
-            if (field.type === 'struct') {
-                const struct = field;
-                if (struct.structSource.type === 'inline') {
-                    retRow[field.name] = this.convertRow(struct, row[i]);
-                }
-                else {
-                    retRow[field.name] = this.convertNest(struct, row[i]);
-                }
+            if (field.type === 'record') {
+                retRow[field.name] = this.convertRow(field, row[i]);
+            }
+            else if ((0, malloy_1.isRepeatedRecord)(field)) {
+                retRow[field.name] = this.convertNest(field, row[i]);
+            }
+            else if (field.type === 'array') {
+                const newArray = {
+                    fields: [],
+                    dialect: '',
+                    ...field,
+                    join: 'many',
+                };
+                retRow[field.name] = this.convertNest(newArray, row[i]);
             }
             else {
-                retRow[field.name] = row[i] === undefined ? null : row[i];
+                retRow[field.name] = (_a = row[i]) !== null && _a !== void 0 ? _a : null;
             }
         }
         //console.log(retRow);
@@ -209,12 +177,6 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
     convertNest(structDef, _data) {
         const data = this.unpackArray(_data);
         const ret = [];
-        //console.log(
-        //   `${JSON.stringify(structDef, null, 2)} ${JSON.stringify(data, null, 2)} `
-        // );
-        if (structDef.structSource.type === 'inline') {
-            return this.convertRow(structDef, data);
-        }
         const rows = (data === null || data === undefined ? [] : data);
         for (const row of rows) {
             ret.push(this.convertRow(structDef, row));
@@ -224,17 +186,6 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
     async runSQL(sqlCommand, options = {}, 
     // TODO(figutierrez): Use.
     _rowIndex = 0) {
-        // const result = await this.trino.query(sqlCommand);
-        // let queryResult = await result.next();
-        // if (queryResult.value.error) {
-        //   // TODO: handle.
-        //   const {failureInfo: _, ...error} = queryResult.value.error;
-        //   throw new Error(
-        //     `Failed to execute sql: ${sqlCommand}. \n Error: ${JSON.stringify(
-        //       error
-        //     )}`
-        //   );
-        // }
         const r = await this.client.runSQL(sqlCommand, options.rowLimit);
         if (r.error) {
             throw new Error(r.error);
@@ -242,37 +193,32 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
         const inputRows = r.rows;
         const columns = r.columns;
         const malloyColumns = columns.map(c => this.malloyTypeFromTrinoType(c.name, c.type));
-        // Debugging types
-        // const _x = queryResult.value.columns.map(c => console.log(c.type));
-        // console.log(JSON.stringify(malloyColumns, null, 2));
-        // console.log(JSON.stringify(queryResult.value.data, null, 2));
         const malloyRows = [];
         const rows = inputRows !== null && inputRows !== void 0 ? inputRows : [];
         for (const row of rows) {
             const malloyRow = {};
             for (let i = 0; i < columns.length; i++) {
                 const column = columns[i];
-                if (malloyColumns[i].type === 'struct') {
-                    const structDef = malloyColumns[i];
-                    if (structDef.structSource.type === 'inline') {
-                        malloyRow[column.name] = this.convertRow(structDef, row[i]);
-                    }
-                    else {
-                        malloyRow[column.name] = this.convertNest(structDef, row[i]);
-                    }
-                    // console.log(
-                    //   column.name,
-                    //   JSON.stringify(malloyColumns[i], null, 2),
-                    //   JSON.stringify(row[i]),
-                    //   JSON.stringify(malloyRow[column.name])
-                    // );
+                const schemaColumn = malloyColumns[i];
+                if (schemaColumn.type === 'record') {
+                    malloyRow[column.name] = this.convertRow(schemaColumn, row[i]);
+                }
+                else if (schemaColumn.type === 'array') {
+                    const newArray = {
+                        name: '',
+                        fields: [],
+                        dialect: '',
+                        ...schemaColumn,
+                        join: 'many',
+                    };
+                    malloyRow[column.name] = this.convertNest(newArray, row[i]);
                 }
-                else if (malloyColumns[i].type === 'number' &&
+                else if (schemaColumn.type === 'number' &&
                     typeof row[i] === 'string') {
                     // decimal numbers come back as strings
                     malloyRow[column.name] = Number(row[i]);
                 }
-                else if (malloyColumns[i].type === 'timestamp' &&
+                else if (schemaColumn.type === 'timestamp' &&
                     typeof row[i] === 'string') {
                     // timestamps come back as strings
                     malloyRow[column.name] = new Date(row[i]);
@@ -283,113 +229,26 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
             }
             malloyRows.push(malloyRow);
         }
-        // TODO(figutierrez): Remove.
-        // eslint-disable-next-line no-console
-        // console.log(`ROWS: ${JSON.stringify(malloyRows)} ${malloyRows.length}`);
-        // TODO: handle totalrows.
         return { rows: malloyRows, totalRows: malloyRows.length };
     }
     async runSQLBlockAndFetchResultSchema(_sqlBlock, _options) {
-        /*const {data, schema: schemaRaw} = await this._runSQL(
-          sqlBlock.selectStr,
-          options
-        );
-    
-        // TODO need to probably surface the cause of the schema not present error
-        if (schemaRaw === undefined) {
-          throw new Error('Schema not present');
-        }
-    
-        const schema = this.structDefFromSQLSchema(sqlBlock, schemaRaw);
-        return {data, schema};*/
         throw new Error('Not implemented 3');
     }
-    async fetchSchemaForTables(missing, { refreshTimestamp }) {
-        const schemas = {};
-        const errors = {};
-        for (const tableKey in missing) {
-            let inCache = this.schemaCache.get(tableKey);
-            const tablePath = missing[tableKey];
-            if (!inCache ||
-                (refreshTimestamp && refreshTimestamp > inCache.timestamp)) {
-                const timestamp = refreshTimestamp !== null && refreshTimestamp !== void 0 ? refreshTimestamp : Date.now();
-                try {
-                    const schema = await this.structDefFromTableSchema(tableKey, 
-                    // TODO: remove.
-                    tablePath);
-                    inCache = {
-                        schema,
-                        timestamp,
-                    };
-                    this.schemaCache.set(tableKey, inCache);
-                }
-                catch (error) {
-                    inCache = { error: error.message, timestamp };
-                }
-            }
-            if (inCache.schema !== undefined) {
-                schemas[tableKey] = inCache.schema;
-            }
-            else {
-                errors[tableKey] = inCache.error || 'Unknown schema fetch error';
-            }
-        }
-        return { schemas: schemas, errors: errors };
-    }
-    async structDefFromTableSchema(tableKey, tablePath) {
+    async fetchTableSchema(tableKey, tablePath) {
         const structDef = {
-            type: 'struct',
+            type: 'table',
             name: tableKey,
             dialect: this.dialectName,
-            structSource: {
-                type: 'table',
-                tablePath,
-            },
-            structRelationship: {
-                type: 'basetable',
-                connectionName: this.name,
-            },
+            tablePath,
+            connection: this.name,
             fields: [],
         };
-        return await this.loadSchemaForSqlBlock(`DESCRIBE ${tablePath}`, structDef, `table ${tablePath}`);
-    }
-    async fetchSchemaForSQLBlock(sqlRef, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    { refreshTimestamp }) {
-        const key = sqlRef.name;
-        let inCache = this.sqlSchemaCache.get(key);
-        if (!inCache ||
-            (refreshTimestamp && refreshTimestamp > inCache.timestamp)) {
-            const timestamp = refreshTimestamp !== null && refreshTimestamp !== void 0 ? refreshTimestamp : Date.now();
-            try {
-                inCache = {
-                    structDef: await this.structDefFromSqlBlock(sqlRef),
-                    timestamp,
-                };
-            }
-            catch (error) {
-                inCache = { error: error.message, timestamp };
-            }
-            this.sqlSchemaCache.set(key, inCache);
-        }
-        return inCache;
+        const schemaDesc = await this.loadSchemaForSqlBlock(`DESCRIBE ${tablePath}`, structDef, `table ${tablePath}`);
+        structDef.fields = schemaDesc.fields;
+        return structDef;
     }
-    async structDefFromSqlBlock(sqlRef) {
-        const structDef = {
-            type: 'struct',
-            name: sqlRef.name,
-            dialect: this.dialectName,
-            structSource: {
-                type: 'sql',
-                method: 'subquery',
-                sqlBlock: sqlRef,
-            },
-            structRelationship: {
-                type: 'basetable',
-                connectionName: this.name,
-            },
-            fields: [],
-        };
+    async fetchSelectSchema(sqlRef) {
+        const structDef = { ...sqlRef, fields: [] };
         await this.fillStructDefForSqlBlockSchema(sqlRef.selectStr, structDef);
         return structDef;
     }
@@ -430,38 +289,34 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
         return columns;
     }
     malloyTypeFromTrinoType(name, trinoType) {
-        var _a;
-        let malloyType;
         // Arrays look like `array(type)`
         const arrayMatch = trinoType.match(/^(([^,])+\s)?array\((.*)\)$/);
-        // console.log(`${trinoType} arrayMatch: ${arrayMatch}`);
         // Structs look like `row(name type, name type)`
         const structMatch = trinoType.match(/^(([^,])+\s)?row\((.*)\)$/);
-        // console.log(`${trinoType} structMatch: ${structMatch}`);
         if (arrayMatch) {
             const arrayType = arrayMatch[3];
             const innerType = this.malloyTypeFromTrinoType(name, arrayType);
-            if (innerType.type === 'struct') {
-                malloyType = { ...innerType, structSource: { type: 'nested' } };
-                malloyType.structRelationship = {
-                    type: 'nested',
-                    fieldName: name,
-                    isArray: false,
+            if (innerType.type === 'record') {
+                const complexStruct = {
+                    type: 'array',
+                    name,
+                    elementTypeDef: { type: 'record_element' },
+                    dialect: this.dialectName,
+                    join: 'many',
+                    fields: innerType.fields,
                 };
+                return complexStruct;
             }
             else {
-                malloyType = {
-                    type: 'struct',
+                const arrayStruct = {
+                    type: 'array',
                     name,
+                    elementTypeDef: innerType,
                     dialect: this.dialectName,
-                    structSource: { type: 'nested' },
-                    structRelationship: {
-                        type: 'nested',
-                        fieldName: name,
-                        isArray: true,
-                    },
-                    fields: [{ ...innerType, name: 'value' }],
+                    join: 'many',
+                    fields: (0, malloy_1.arrayEachFields)(innerType),
                 };
+                return arrayStruct;
             }
         }
         else if (structMatch) {
@@ -469,15 +324,11 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
             // so some magic is going to need to be applied before we get here
             // to avoid confusion if a field name contains a comma
             const innerTypes = this.splitColumns(structMatch[3]);
-            // console.log(`innerType: ${JSON.stringify(innerTypes)}`);
-            malloyType = {
-                type: 'struct',
+            const recordType = {
+                type: 'record',
                 name,
                 dialect: this.dialectName,
-                structSource: { type: 'inline' },
-                structRelationship: {
-                    type: 'inline',
-                },
+                join: 'one',
                 fields: [],
             };
             for (let innerType of innerTypes) {
@@ -493,25 +344,12 @@ class TrinoPrestoConnection extends connection_1.BaseConnection {
                     const innerName = parts[1].replace(/^"(.+(?="$))"$/, '$1');
                     const innerTrinoType = parts[2];
                     const innerMalloyType = this.malloyTypeFromTrinoType(innerName, innerTrinoType);
-                    malloyType.fields.push({ ...innerMalloyType, name: innerName });
-                }
-                else {
-                    malloyType.fields.push({
-                        name: 'unknown',
-                        type: 'sql native',
-                        rawType: innerType.toLowerCase(),
-                    });
+                    recordType.fields.push({ ...innerMalloyType, name: innerName });
                 }
             }
+            return recordType;
         }
-        else {
-            malloyType = (_a = this.sqlToMalloyType(trinoType)) !== null && _a !== void 0 ? _a : {
-                type: 'sql native',
-                rawType: trinoType.toLowerCase(),
-            };
-        }
-        // console.log('>', trinoType, '\n<', malloyType);
-        return malloyType;
+        return this.dialect.sqlTypeToMalloyType(trinoType);
     }
     structDefFromSchema(rows, structDef) {
         for (const row of rows) {

package/dist/trino_connection.spec.js

@@ -22,6 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+const malloy_1 = require("@malloydata/malloy");
 const _1 = require(".");
 // array(varchar) is array
 const ARRAY_SCHEMA = 'array(integer)';
@@ -31,6 +32,14 @@ const INLINE_SCHEMA = 'row(a double, b integer, c varchar(60))';
 const NESTED_SCHEMA = 'array(row(a double, b integer, c varchar(60)))';
 // array(row(..., array(row(....)))) is deeply nested
 const DEEP_SCHEMA = 'array(row(a double, b array(row(c integer, d varchar(60)))))';
+const intType = { type: 'number', numberType: 'integer' };
+const doubleType = { type: 'number', numberType: 'float' };
+const stringType = { type: 'string' };
+const recordSchema = [
+    { name: 'a', ...doubleType },
+    { name: 'b', ...intType },
+    { name: 'c', ...stringType },
+];
 describe('Trino connection', () => {
     let connection;
     beforeAll(() => {
@@ -43,118 +52,53 @@ describe('Trino connection', () => {
         it('parses arrays', () => {
             expect(connection.malloyTypeFromTrinoType('test', ARRAY_SCHEMA)).toEqual({
                 'name': 'test',
-                'type': 'struct',
+                'type': 'array',
                 'dialect': 'trino',
-                'structRelationship': {
-                    'fieldName': 'test',
-                    'isArray': true,
-                    'type': 'nested',
-                },
-                'structSource': {
-                    'type': 'nested',
-                },
-                'fields': [
-                    {
-                        'name': 'value',
-                        'type': 'number',
-                        'numberType': 'integer',
-                    },
-                ],
+                'elementTypeDef': intType,
+                'join': 'many',
+                'fields': (0, malloy_1.arrayEachFields)(intType),
             });
         });
         it('parses inline', () => {
             expect(connection.malloyTypeFromTrinoType('test', INLINE_SCHEMA)).toEqual({
                 'name': 'test',
-                'type': 'struct',
+                'type': 'record',
                 'dialect': 'trino',
-                'structRelationship': {
-                    'type': 'inline',
-                },
-                'structSource': {
-                    'type': 'inline',
-                },
-                'fields': [
-                    {
-                        'name': 'a',
-                        'type': 'number',
-                        'numberType': 'float',
-                    },
-                    {
-                        'name': 'b',
-                        'type': 'number',
-                        'numberType': 'integer',
-                    },
-                    {
-                        'name': 'c',
-                        'type': 'string',
-                    },
-                ],
+                'join': 'one',
+                'fields': recordSchema,
             });
         });
         it('parses nested', () => {
             expect(connection.malloyTypeFromTrinoType('test', NESTED_SCHEMA)).toEqual({
                 'name': 'test',
-                'type': 'struct',
+                'type': 'array',
+                'elementTypeDef': { type: 'record_element' },
                 'dialect': 'trino',
-                'structRelationship': {
-                    'fieldName': 'test',
-                    'isArray': false,
-                    'type': 'nested',
-                },
-                'structSource': { 'type': 'nested' },
-                'fields': [
-                    { 'name': 'a', 'numberType': 'float', 'type': 'number' },
-                    { 'name': 'b', 'numberType': 'integer', 'type': 'number' },
-                    { 'name': 'c', 'type': 'string' },
-                ],
+                'join': 'many',
+                'fields': recordSchema,
             });
         });
         it('parses a simple type', () => {
-            expect(connection.malloyTypeFromTrinoType('test', 'varchar(60)')).toEqual({
-                'type': 'string',
-            });
+            expect(connection.malloyTypeFromTrinoType('test', 'varchar(60)')).toEqual(stringType);
         });
         it('parses deep nesting', () => {
             expect(connection.malloyTypeFromTrinoType('test', DEEP_SCHEMA)).toEqual({
                 'name': 'test',
-                'type': 'struct',
+                'type': 'array',
                 'dialect': 'trino',
-                'structRelationship': {
-                    'fieldName': 'test',
-                    'isArray': false,
-                    'type': 'nested',
-                },
-                'structSource': {
-                    'type': 'nested',
-                },
+                'elementTypeDef': { type: 'record_element' },
+                'join': 'many',
                 'fields': [
-                    {
-                        'name': 'a',
-                        'numberType': 'float',
-                        'type': 'number',
-                    },
+                    { 'name': 'a', ...doubleType },
                     {
                         'name': 'b',
-                        'type': 'struct',
+                        'type': 'array',
                         'dialect': 'trino',
-                        'structRelationship': {
-                            'fieldName': 'b',
-                            'isArray': false,
-                            'type': 'nested',
-                        },
-                        'structSource': {
-                            'type': 'nested',
-                        },
+                        'elementTypeDef': { type: 'record_element' },
+                        'join': 'many',
                         'fields': [
-                            {
-                                'name': 'c',
-                                'numberType': 'integer',
-                                'type': 'number',
-                            },
-                            {
-                                'name': 'd',
-                                'type': 'string',
-                            },
+                            { 'name': 'c', ...intType },
+                            { 'name': 'd', ...stringType },
                         ],
                     },
                 ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-trino",
-  "version": "0.0.195-dev241003204819",
+  "version": "0.0.195-dev241007154000",
   "license": "MIT",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -22,7 +22,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@malloydata/malloy": "^0.0.195-dev241003204819",
+    "@malloydata/malloy": "^0.0.195-dev241007154000",
     "@prestodb/presto-js-client": "^1.0.0",
     "gaxios": "^4.2.0",
     "trino-client": "^0.2.2"