@malloydata/malloy 0.0.327 → 0.0.329

package/dist/dialect/dialect.d.ts

@@ -34,26 +34,16 @@ export type OrderByClauseType = 'output_name' | 'ordinal' | 'expression';
 export type OrderByRequest = 'query' | 'turtle' | 'analytical';
 export type BooleanTypeSupport = 'supported' | 'simulated' | 'none';
 /**
- * Min/max range for an integer type.
- * - null: type is not supported by this dialect
- * - {min, max}: the range of values (use the exported constants like MIN_INT64, MAX_INT64)
- */
-export type IntegerTypeRange = {
-    min: number | bigint;
-    max: number | bigint;
-} | null;
-/**
- * Configuration for integer literal type selection.
+ * Maps a range of integer values to a Malloy number type.
  *
- * When translating an integer literal, the translator walks down this list
- * (integer → bigint) and selects the first type that can hold the value.
- * If no type can hold the value (or all are null), an error is raised.
+ * Dialects define an array of these mappings to describe how integer literals
+ * should be typed. The array is searched in order, and the first matching
+ * range determines the type.
  */
-export interface IntegerTypeLimits {
-    /** Range for 'integer' type (-2^53 to 2^53-1, safe for JS Number) */
-    integer: IntegerTypeRange;
-    /** Range for 'bigint' type (64-bit or larger integers, varies by dialect) */
-    bigint: IntegerTypeRange;
+export interface IntegerTypeMapping {
+    min: bigint;
+    max: bigint;
+    numberType: 'integer' | 'bigint';
 }
 export declare abstract class Dialect {
     abstract name: string;
@@ -94,10 +84,19 @@ export declare abstract class Dialect {
     booleanType: BooleanTypeSupport;
     likeEscape: boolean;
     /**
-     * Ranges for integer types in this dialect.
-     * Default supports integer (JS safe) and bigint (64-bit signed).
+     * Mappings from integer value ranges to Malloy number types.
+     *
+     * The array is searched in order; the first matching range determines the type.
+     * Default: small integers (≤32-bit) → 'integer', larger → 'bigint'.
+     */
+    integerTypeMappings: IntegerTypeMapping[];
+    /**
+     * Determine the Malloy number type for a numeric literal.
      */
-    integerTypeLimits: IntegerTypeLimits;
+    literalNumberType(value: string): {
+        type: 'number';
+        numberType: 'integer' | 'float' | 'bigint';
+    };
     /**
      * Create the appropriate time literal IR node based on dialect support.
      * Static method so it can be called with undefined dialect (e.g., ConstantFieldSpace).

package/dist/dialect/dialect.js

@@ -28,7 +28,7 @@ exports.qtz = qtz;
 const malloy_types_1 = require("../model/malloy_types");
 /*
  * Standard integer type limits.
- * Use these in dialect integerTypeLimits definitions.
+ * Use these in dialect integerTypeMappings definitions.
  */
 // 32-bit signed integer limits (for databases with 32-bit INTEGER type)
 exports.MIN_INT32 = -2147483648; // -2^31
@@ -110,13 +110,32 @@ class Dialect {
         // Like characters are escaped with ESCAPE clause
         this.likeEscape = true;
         /**
-         * Ranges for integer types in this dialect.
-         * Default supports integer (JS safe) and bigint (64-bit signed).
+         * Mappings from integer value ranges to Malloy number types.
+         *
+         * The array is searched in order; the first matching range determines the type.
+         * Default: small integers (≤32-bit) → 'integer', larger → 'bigint'.
          */
-        this.integerTypeLimits = {
-            integer: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
-            bigint: { min: exports.MIN_INT64, max: exports.MAX_INT64 },
-        };
+        this.integerTypeMappings = [
+            { min: BigInt(exports.MIN_INT32), max: BigInt(exports.MAX_INT32), numberType: 'integer' },
+            { min: exports.MIN_INT64, max: exports.MAX_INT64, numberType: 'bigint' },
+        ];
+    }
+    /**
+     * Determine the Malloy number type for a numeric literal.
+     */
+    literalNumberType(value) {
+        const isInteger = /^-?\d+$/.test(value);
+        if (!isInteger) {
+            return { type: 'number', numberType: 'float' };
+        }
+        const bigValue = BigInt(value);
+        for (const mapping of this.integerTypeMappings) {
+            if (bigValue >= mapping.min && bigValue <= mapping.max) {
+                return { type: 'number', numberType: mapping.numberType };
+            }
+        }
+        // Value exceeds all supported ranges - let SQL fail at runtime
+        return { type: 'number', numberType: 'bigint' };
     }
     /**
      * Create the appropriate time literal IR node based on dialect support.

package/dist/dialect/duckdb/duckdb.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, OrderBy, TimestampUnit } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { DialectFieldList, FieldReferenceType, IntegerTypeLimits } from '../dialect';
+import type { DialectFieldList, FieldReferenceType, IntegerTypeMapping } from '../dialect';
 import { PostgresBase } from '../pg_impl';
 export declare class DuckDBDialect extends PostgresBase {
     name: string;
@@ -22,7 +22,7 @@ export declare class DuckDBDialect extends PostgresBase {
     supportsSafeCast: boolean;
     supportsNesting: boolean;
     supportsCountApprox: boolean;
-    integerTypeLimits: IntegerTypeLimits;
+    integerTypeMappings: IntegerTypeMapping[];
     get udfPrefix(): string;
     quoteTablePath(tableName: string): string;
     sqlGroupSetTable(groupSetCount: number): string;

package/dist/dialect/duckdb/duckdb.js

@@ -73,11 +73,11 @@ class DuckDBDialect extends pg_impl_1.PostgresBase {
         this.supportsSafeCast = true;
         this.supportsNesting = true;
         this.supportsCountApprox = true;
-        // DuckDB supports HUGEINT (128-bit signed integer)
-        this.integerTypeLimits = {
-            integer: { min: dialect_1.MIN_INT32, max: dialect_1.MAX_INT32 },
-            bigint: { min: dialect_1.MIN_INT128, max: dialect_1.MAX_INT128 },
-        };
+        // DuckDB: 32-bit INTEGER is safe, larger integers need bigint
+        this.integerTypeMappings = [
+            { min: BigInt(dialect_1.MIN_INT32), max: BigInt(dialect_1.MAX_INT32), numberType: 'integer' },
+            { min: dialect_1.MIN_INT128, max: dialect_1.MAX_INT128, numberType: 'bigint' },
+        ];
     }
     // hack until they support temporary macros.
     get udfPrefix() {

package/dist/dialect/snowflake/snowflake.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, MeasureTimeExpr, RegexMatchExpr, BasicAtomicTypeDef, TimestampTypeDef, ArrayLiteralNode, RecordLiteralNode } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { DialectFieldList, FieldReferenceType, IntegerTypeLimits, QueryInfo } from '../dialect';
+import type { DialectFieldList, FieldReferenceType, IntegerTypeMapping, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 export declare class SnowflakeDialect extends Dialect {
     name: string;
@@ -26,7 +26,7 @@ export declare class SnowflakeDialect extends Dialect {
     supportsQualify: boolean;
     supportsPipelinesInViews: boolean;
     supportsComplexFilteredSources: boolean;
-    integerTypeLimits: IntegerTypeLimits;
+    integerTypeMappings: IntegerTypeMapping[];
     quoteTablePath(tablePath: string): string;
     sqlGroupSetTable(groupSetCount: number): string;
     sqlAnyValue(groupSet: number, fieldName: string): string;

package/dist/dialect/snowflake/snowflake.js

@@ -98,11 +98,10 @@ class SnowflakeDialect extends dialect_1.Dialect {
         this.supportsQualify = false;
         this.supportsPipelinesInViews = false;
         this.supportsComplexFilteredSources = false;
-        // Snowflake uses NUMBER(38,0) for all integers - only one integer type
-        this.integerTypeLimits = {
-            integer: { min: dialect_1.MIN_DECIMAL38, max: dialect_1.MAX_DECIMAL38 },
-            bigint: null,
-        };
+        // Snowflake uses NUMBER(38,0) for all integers - can exceed JS Number precision
+        this.integerTypeMappings = [
+            { min: dialect_1.MIN_DECIMAL38, max: dialect_1.MAX_DECIMAL38, numberType: 'bigint' },
+        ];
     }
     // don't mess with the table pathing.
     quoteTablePath(tablePath) {

package/dist/dialect/standardsql/standardsql.d.ts

@@ -1,6 +1,6 @@
 import type { Sampling, AtomicTypeDef, TimeExtractExpr, TypecastExpr, RegexMatchExpr, MeasureTimeExpr, BasicAtomicTypeDef, RecordLiteralNode, ArrayLiteralNode, TimestampUnit, TimestampTypeDef } from '../../model/malloy_types';
 import type { DialectFunctionOverloadDef } from '../functions';
-import type { DialectFieldList, IntegerTypeLimits, OrderByRequest, QueryInfo } from '../dialect';
+import type { DialectFieldList, IntegerTypeMapping, OrderByRequest, QueryInfo } from '../dialect';
 import { Dialect } from '../dialect';
 export declare class StandardSQLDialect extends Dialect {
     name: string;
@@ -27,7 +27,7 @@ export declare class StandardSQLDialect extends Dialect {
     nestedArrays: boolean;
     supportsHyperLogLog: boolean;
     likeEscape: boolean;
-    integerTypeLimits: IntegerTypeLimits;
+    integerTypeMappings: IntegerTypeMapping[];
     quoteTablePath(tablePath: string): string;
     needsCivilTimeComputation(typeDef: AtomicTypeDef, truncateTo: TimestampUnit | undefined, offsetUnit: TimestampUnit | undefined, qi: QueryInfo): {
         needed: boolean;

package/dist/dialect/standardsql/standardsql.js

@@ -97,11 +97,10 @@ class StandardSQLDialect extends dialect_1.Dialect {
         this.nestedArrays = false; // Can't have an array of arrays for some reason
         this.supportsHyperLogLog = true;
         this.likeEscape = false; // Uses \ instead of ESCAPE 'X' in like clauses
-        // BigQuery only has INT64 - no 32-bit integer type
-        this.integerTypeLimits = {
-            integer: { min: dialect_1.MIN_INT64, max: dialect_1.MAX_INT64 },
-            bigint: null,
-        };
+        // BigQuery only has INT64 - all integers can exceed JS Number precision
+        this.integerTypeMappings = [
+            { min: dialect_1.MIN_INT64, max: dialect_1.MAX_INT64, numberType: 'bigint' },
+        ];
     }
     quoteTablePath(tablePath) {
         return `\`${tablePath}\``;

package/dist/lang/ast/expressions/expr-number.d.ts

@@ -7,19 +7,15 @@ export declare class ExprNumber extends ExpressionDef {
     elementType: string;
     constructor(n: string);
     getExpression(fs: FieldSpace): ExprValue;
+    /**
+     * Default number type when no dialect is available.
+     * Integers default to bigint for safety, floats to float.
+     */
+    private defaultNumberType;
     /**
      * For constants (no dialect context), always use bigint for integers
      * to ensure large values render correctly.
      */
     constantExpression(): ExprValue;
-    /**
-     * Select the appropriate integer type based on dialect limits.
-     * Returns null if no type can hold the value.
-     */
-    private selectIntegerType;
-    /**
-     * Get the largest supported range for error messages.
-     */
-    private getMaxRange;
     getStableLiteral(): Malloy.LiteralValue;
 }

package/dist/lang/ast/expressions/expr-number.js

@@ -32,82 +32,33 @@ class ExprNumber extends expression_def_1.ExpressionDef {
         this.elementType = 'numeric literal';
     }
     getExpression(fs) {
-        var _a, _b;
-        // Check if this is an integer (no decimal point, no exponent notation)
-        const isInteger = /^-?\d+$/.test(this.n);
-        if (!isInteger) {
-            return (0, expr_value_1.literalExprValue)({
-                dataType: { type: 'number', numberType: 'float' },
-                value: { node: 'numberLiteral', literal: this.n },
-            });
-        }
+        var _a;
         const dialect = fs.dialectObj();
-        const limits = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.integerTypeLimits) !== null && _a !== void 0 ? _a : {
-            integer: { min: Number.MIN_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
-            bigint: null,
-        };
-        const literalValue = BigInt(this.n);
-        const numberType = this.selectIntegerType(literalValue, limits);
-        if (numberType === null) {
-            // Find the largest supported range for the error message
-            const maxRange = this.getMaxRange(limits);
-            this.logError('integer-literal-out-of-range', `Integer literal ${this.n} exceeds ${(_b = dialect === null || dialect === void 0 ? void 0 : dialect.name) !== null && _b !== void 0 ? _b : 'dialect'} integer range [${maxRange.min} to ${maxRange.max}]`);
-            // Fall back to bigint so we can continue compilation
-            return (0, expr_value_1.literalExprValue)({
-                dataType: { type: 'number', numberType: 'bigint' },
-                value: { node: 'numberLiteral', literal: this.n },
-            });
-        }
+        const dataType = (_a = dialect === null || dialect === void 0 ? void 0 : dialect.literalNumberType(this.n)) !== null && _a !== void 0 ? _a : this.defaultNumberType();
         return (0, expr_value_1.literalExprValue)({
-            dataType: { type: 'number', numberType },
+            dataType,
             value: { node: 'numberLiteral', literal: this.n },
         });
     }
     /**
-     * For constants (no dialect context), always use bigint for integers
-     * to ensure large values render correctly.
+     * Default number type when no dialect is available.
+     * Integers default to bigint for safety, floats to float.
      */
-    constantExpression() {
+    defaultNumberType() {
         const isInteger = /^-?\d+$/.test(this.n);
-        const dataType = isInteger
+        return isInteger
             ? { type: 'number', numberType: 'bigint' }
             : { type: 'number', numberType: 'float' };
-        return (0, expr_value_1.literalExprValue)({
-            dataType,
-            value: { node: 'numberLiteral', literal: this.n },
-        });
     }
     /**
-     * Select the appropriate integer type based on dialect limits.
-     * Returns null if no type can hold the value.
-     */
-    selectIntegerType(value, limits) {
-        const types = ['integer', 'bigint'];
-        for (const numType of types) {
-            const range = limits[numType];
-            if (range !== null) {
-                // Comparison between bigint and number works in JS
-                if (value >= range.min && value <= range.max) {
-                    return numType;
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Get the largest supported range for error messages.
+     * For constants (no dialect context), always use bigint for integers
+     * to ensure large values render correctly.
      */
-    getMaxRange(limits) {
-        // Check in reverse order to find the largest supported type
-        const types = ['bigint', 'integer'];
-        for (const numType of types) {
-            const range = limits[numType];
-            if (range !== null) {
-                return range;
-            }
-        }
-        // Should never happen, but fallback
-        return { min: 0, max: 0 };
+    constantExpression() {
+        return (0, expr_value_1.literalExprValue)({
+            dataType: this.defaultNumberType(),
+            value: { node: 'numberLiteral', literal: this.n },
+        });
     }
     getStableLiteral() {
         return {

package/dist/malloy.js

@@ -2432,7 +2432,12 @@ class Result extends PreparedResult {
         return this.inner.profilingUrl;
     }
     toJSON() {
-        return { queryResult: this.inner, modelDef: this._modelDef };
+        // The result rows are converted to JSON separately because they
+        // may contain un-serializable data types.
+        return {
+            queryResult: { ...this.inner, result: this.data.toJSON() },
+            modelDef: this._modelDef,
+        };
     }
     static fromJSON({ queryResult, modelDef }) {
         return new Result(queryResult, modelDef);

package/dist/test/index.d.ts

@@ -1,3 +1,43 @@
+import type { Connection, URLReader, EventStream, CacheManager } from '..';
+import { SingleConnectionRuntime } from '..';
+/**
+ * Options for createTestRuntime.
+ */
+export interface TestRuntimeOptions {
+    /** Custom URL reader. Defaults to reading from filesystem. */
+    urlReader?: URLReader;
+    /** Event stream for runtime events. */
+    eventStream?: EventStream;
+    /** Cache manager for model caching. */
+    cacheManager?: CacheManager;
+}
+/**
+ * Create a SingleConnectionRuntime for testing.
+ *
+ * By default, creates a runtime with a file URL reader that reads from the filesystem.
+ * Options can be provided to customize the URL reader, event stream, and cache manager.
+ *
+ * @example
+ * // Simple usage (connection package tests)
+ * import { createTestRuntime } from '@malloydata/malloy/test';
+ * import { BigQueryConnection } from '@malloydata/malloy-db-bigquery';
+ *
+ * const bq = new BigQueryConnection('test');
+ * const runtime = createTestRuntime(bq);
+ *
+ * @example
+ * // With options (internal test infrastructure)
+ * const runtime = createTestRuntime(connection, {
+ *   urlReader: customReader,
+ *   eventStream: new EventEmitter(),
+ *   cacheManager: new TestCacheManager(),
+ * });
+ *
+ * @param connection - The database connection to use
+ * @param options - Optional configuration for the runtime
+ * @returns A SingleConnectionRuntime configured for testing
+ */
+export declare function createTestRuntime<T extends Connection>(connection: T, options?: TestRuntimeOptions): SingleConnectionRuntime<T>;
 export { TV } from './test-values';
 export type { TypedValue } from './test-values';
 export { mkTestModel, wrapTestModel, extendTestModel } from './test-models';

package/dist/test/index.js

@@ -3,11 +3,90 @@
  * Copyright Contributors to the Malloy project
  * SPDX-License-Identifier: MIT
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runQuery = exports.extendTestModel = exports.wrapTestModel = exports.mkTestModel = exports.TV = void 0;
+exports.createTestRuntime = createTestRuntime;
 exports.databasesFromEnvironmentOr = databasesFromEnvironmentOr;
 exports.describeIfDatabaseAvailable = describeIfDatabaseAvailable;
 exports.brokenIn = brokenIn;
+const fs = __importStar(require("fs"));
+const util = __importStar(require("util"));
+const url_1 = require("url");
+const __1 = require("..");
+/**
+ * Create a SingleConnectionRuntime for testing.
+ *
+ * By default, creates a runtime with a file URL reader that reads from the filesystem.
+ * Options can be provided to customize the URL reader, event stream, and cache manager.
+ *
+ * @example
+ * // Simple usage (connection package tests)
+ * import { createTestRuntime } from '@malloydata/malloy/test';
+ * import { BigQueryConnection } from '@malloydata/malloy-db-bigquery';
+ *
+ * const bq = new BigQueryConnection('test');
+ * const runtime = createTestRuntime(bq);
+ *
+ * @example
+ * // With options (internal test infrastructure)
+ * const runtime = createTestRuntime(connection, {
+ *   urlReader: customReader,
+ *   eventStream: new EventEmitter(),
+ *   cacheManager: new TestCacheManager(),
+ * });
+ *
+ * @param connection - The database connection to use
+ * @param options - Optional configuration for the runtime
+ * @returns A SingleConnectionRuntime configured for testing
+ */
+function createTestRuntime(connection, options) {
+    var _a;
+    const urlReader = (_a = options === null || options === void 0 ? void 0 : options.urlReader) !== null && _a !== void 0 ? _a : {
+        readURL: async (url) => {
+            const filePath = (0, url_1.fileURLToPath)(url);
+            return await util.promisify(fs.readFile)(filePath, 'utf8');
+        },
+    };
+    return new __1.SingleConnectionRuntime({
+        urlReader,
+        connection,
+        eventStream: options === null || options === void 0 ? void 0 : options.eventStream,
+        cacheManager: options === null || options === void 0 ? void 0 : options.cacheManager,
+    });
+}
 // Test data creation
 var test_values_1 = require("./test-values");
 Object.defineProperty(exports, "TV", { enumerable: true, get: function () { return test_values_1.TV; } });

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.327";
+export declare const MALLOY_VERSION = "0.0.329";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.327';
+exports.MALLOY_VERSION = '0.0.329';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.327",
+  "version": "0.0.329",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -45,9 +45,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.327",
-    "@malloydata/malloy-interfaces": "0.0.327",
-    "@malloydata/malloy-tag": "0.0.327",
+    "@malloydata/malloy-filter": "0.0.329",
+    "@malloydata/malloy-interfaces": "0.0.329",
+    "@malloydata/malloy-tag": "0.0.329",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",