@malloydata/malloy 0.0.337 → 0.0.339

package/dist/lang/lib/Malloy/MalloyParserListener.d.ts

@@ -198,6 +198,9 @@ import { QueryAnnotationContext } from "./MalloyParser";
 import { SampleSpecContext } from "./MalloyParser";
 import { AggregateContext } from "./MalloyParser";
 import { MalloyTypeContext } from "./MalloyParser";
+import { MalloyBasicTypeContext } from "./MalloyParser";
+import { MalloyRecordTypeContext } from "./MalloyParser";
+import { MalloyRecordFieldContext } from "./MalloyParser";
 import { CompareOpContext } from "./MalloyParser";
 import { StringContext } from "./MalloyParser";
 import { ShortStringContext } from "./MalloyParser";
@@ -2405,6 +2408,36 @@ export interface MalloyParserListener extends ParseTreeListener {
      * @param ctx the parse tree
      */
     exitMalloyType?: (ctx: MalloyTypeContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.malloyBasicType`.
+     * @param ctx the parse tree
+     */
+    enterMalloyBasicType?: (ctx: MalloyBasicTypeContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.malloyBasicType`.
+     * @param ctx the parse tree
+     */
+    exitMalloyBasicType?: (ctx: MalloyBasicTypeContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.malloyRecordType`.
+     * @param ctx the parse tree
+     */
+    enterMalloyRecordType?: (ctx: MalloyRecordTypeContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.malloyRecordType`.
+     * @param ctx the parse tree
+     */
+    exitMalloyRecordType?: (ctx: MalloyRecordTypeContext) => void;
+    /**
+     * Enter a parse tree produced by `MalloyParser.malloyRecordField`.
+     * @param ctx the parse tree
+     */
+    enterMalloyRecordField?: (ctx: MalloyRecordFieldContext) => void;
+    /**
+     * Exit a parse tree produced by `MalloyParser.malloyRecordField`.
+     * @param ctx the parse tree
+     */
+    exitMalloyRecordField?: (ctx: MalloyRecordFieldContext) => void;
     /**
      * Enter a parse tree produced by `MalloyParser.compareOp`.
      * @param ctx the parse tree

package/dist/lang/lib/Malloy/MalloyParserVisitor.d.ts

@@ -198,6 +198,9 @@ import { QueryAnnotationContext } from "./MalloyParser";
 import { SampleSpecContext } from "./MalloyParser";
 import { AggregateContext } from "./MalloyParser";
 import { MalloyTypeContext } from "./MalloyParser";
+import { MalloyBasicTypeContext } from "./MalloyParser";
+import { MalloyRecordTypeContext } from "./MalloyParser";
+import { MalloyRecordFieldContext } from "./MalloyParser";
 import { CompareOpContext } from "./MalloyParser";
 import { StringContext } from "./MalloyParser";
 import { ShortStringContext } from "./MalloyParser";
@@ -1528,6 +1531,24 @@ export interface MalloyParserVisitor<Result> extends ParseTreeVisitor<Result> {
      * @return the visitor result
      */
     visitMalloyType?: (ctx: MalloyTypeContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.malloyBasicType`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMalloyBasicType?: (ctx: MalloyBasicTypeContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.malloyRecordType`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMalloyRecordType?: (ctx: MalloyRecordTypeContext) => Result;
+    /**
+     * Visit a parse tree produced by `MalloyParser.malloyRecordField`.
+     * @param ctx the parse tree
+     * @return the visitor result
+     */
+    visitMalloyRecordField?: (ctx: MalloyRecordFieldContext) => Result;
     /**
      * Visit a parse tree produced by `MalloyParser.compareOp`.
      * @param ctx the parse tree

package/dist/lang/malloy-to-ast.d.ts

@@ -8,8 +8,7 @@ import type { LogMessageOptions, MessageCode, MessageLogger, MessageParameterTyp
 import type { MalloyParseInfo } from './malloy-parse-info';
 import type { FieldDeclarationConstructor } from './ast';
 import type { HasString, HasID } from './parse-utils';
-import type { CastType } from '../model';
-import type { AccessModifierLabel, DocumentLocation, DocumentRange, Note } from '../model/malloy_types';
+import type { AccessModifierLabel, AtomicTypeDef, BasicAtomicTypeDef, DocumentLocation, DocumentRange, Note } from '../model/malloy_types';
 import type { Tag } from '@malloydata/malloy-tag';
 import type * as Malloy from '@malloydata/malloy-interfaces';
 import { Timer } from '../timing';
@@ -187,8 +186,9 @@ export declare class MalloyToAST extends AbstractParseTreeVisitor<ast.MalloyElem
     visitExprApply(pcx: parse.ExprApplyContext): ast.Apply;
     visitExprRange(pcx: parse.ExprRangeContext): ast.Range;
     visitExprCast(pcx: parse.ExprCastContext): ast.ExpressionDef;
-    getMalloyType(pcx: parse.MalloyTypeContext): CastType;
-    getMalloyOrSQLType(pcx: parse.MalloyOrSQLTypeContext): CastType | {
+    getBasicMalloyType(pcx: parse.MalloyBasicTypeContext): BasicAtomicTypeDef;
+    getMalloyType(pcx: parse.MalloyTypeContext): AtomicTypeDef;
+    getMalloyOrSQLType(pcx: parse.MalloyOrSQLTypeContext): AtomicTypeDef | {
         raw: string;
     };
     visitExprSafeCast(pcx: parse.ExprSafeCastContext): ast.ExpressionDef;

package/dist/lang/malloy-to-ast.js

@@ -289,7 +289,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         let pType;
         const typeCx = pcx.legalParamType();
         if (typeCx) {
-            const t = this.getMalloyType(typeCx.malloyType());
+            const typeDef = this.getBasicMalloyType(typeCx.malloyBasicType());
+            const t = typeDef.type;
             if (typeCx.FILTER()) {
                 if ((0, malloy_filter_1.isFilterable)(t)) {
                     pType = { type: 'filter expression', filterType: t };
@@ -298,11 +299,11 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
                     this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown filter type ${t}`);
                 }
             }
-            else if ((0, malloy_types_1.isParameterType)(t)) {
-                pType = { type: t };
+            else if (!(0, malloy_types_1.isParameterType)(t)) {
+                this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown parameter type ${t}`);
             }
             else {
-                this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown parameter type ${t}`);
+                pType = { type: t };
             }
         }
         const defaultCx = pcx.fieldExpr();
@@ -1092,12 +1093,34 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         const type = this.getMalloyOrSQLType(pcx.malloyOrSQLType());
         return new ast.ExprCast(this.getFieldExpr(pcx.fieldExpr()), type);
     }
-    getMalloyType(pcx) {
+    getBasicMalloyType(pcx) {
         const type = pcx.text;
-        if ((0, malloy_types_1.isCastType)(type)) {
-            return type;
+        if ((0, malloy_types_1.isBasicAtomicType)(type)) {
+            return { type };
+        }
+        this.contextError(pcx, 'unexpected-malloy-type', `Unknown type '${type}'`);
+        return { type: 'error' };
+    }
+    getMalloyType(pcx) {
+        const basicCx = pcx.malloyBasicType();
+        if (basicCx) {
+            return this.getBasicMalloyType(basicCx);
+        }
+        const recordCx = pcx.malloyRecordType();
+        if (recordCx) {
+            const fields = recordCx.malloyRecordField().map(fieldCx => {
+                const name = (0, parse_utils_1.getId)(fieldCx);
+                const fieldType = this.getMalloyType(fieldCx.malloyType());
+                return (0, malloy_types_1.mkFieldDef)(fieldType, name);
+            });
+            return { type: 'record', fields };
+        }
+        const innerCx = pcx.malloyType();
+        if (innerCx) {
+            return (0, malloy_types_1.mkArrayTypeDef)(this.getMalloyType(innerCx));
         }
-        throw this.internalError(pcx, `unknown type '${type}'`);
+        this.contextError(pcx, 'unexpected-malloy-type', 'Expected a type');
+        return { type: 'error' };
     }
     getMalloyOrSQLType(pcx) {
         const mtcx = pcx.malloyType();
@@ -1141,22 +1164,15 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return this.astAt(new ast.ExprFunc(fn, args, false, undefined, source), pcx);
     }
     visitExprFunc(pcx) {
-        var _a, _b;
+        var _a;
         const argsCx = pcx.argumentList();
         const args = argsCx ? this.allFieldExpressions(argsCx.fieldExpr()) : [];
         const isRaw = pcx.EXCLAM() !== undefined;
-        const rawRawType = (_a = pcx.malloyType()) === null || _a === void 0 ? void 0 : _a.text;
-        let rawType = undefined;
-        if (rawRawType) {
-            if ((0, malloy_types_1.isCastType)(rawRawType)) {
-                rawType = rawRawType;
-            }
-            else {
-                this.contextError(pcx, 'unexpected-malloy-type', `'#' assertion for unknown type '${rawRawType}'`);
-                rawType = undefined;
-            }
-        }
-        let fn = (0, parse_utils_1.getOptionalId)(pcx) || ((_b = pcx.timeframe()) === null || _b === void 0 ? void 0 : _b.text);
+        const malloyTypeCx = pcx.malloyType();
+        const explicitType = malloyTypeCx
+            ? this.getMalloyType(malloyTypeCx)
+            : undefined;
+        let fn = (0, parse_utils_1.getOptionalId)(pcx) || ((_a = pcx.timeframe()) === null || _a === void 0 ? void 0 : _a.text);
         if (fn === undefined) {
             this.contextError(pcx, 'failed-to-parse-function-name', 'Function name error');
             fn = 'FUNCTION_NAME_ERROR';
@@ -1164,7 +1180,7 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         if (ast.ExprTimeExtract.extractor(fn)) {
             return this.astAt(new ast.ExprTimeExtract(fn, args), pcx);
         }
-        return this.astAt(new ast.ExprFunc(fn, args, isRaw, rawType), pcx);
+        return this.astAt(new ast.ExprFunc(fn, args, isRaw, explicitType), pcx);
     }
     visitExprDuration(pcx) {
         return new ast.ExprDuration(this.getFieldExpr(pcx.fieldExpr()), this.visitTimeframe(pcx.timeframe()).text);

package/dist/model/malloy_types.d.ts

@@ -159,7 +159,7 @@ export interface MalloyTypecastExpr extends ExprE {
     node: 'cast';
     safe: boolean;
     e: Expr;
-    dstType: BasicAtomicTypeDef;
+    dstType: AtomicTypeDef;
     srcType?: BasicAtomicTypeDef;
 }
 interface RawTypeCastExpr extends ExprE {
@@ -402,11 +402,11 @@ export interface HasExpression {
 export declare function hasExpression<T extends FieldDef>(f: T): f is T & Expression & HasExpression;
 export type TemporalFieldType = 'date' | 'timestamp' | 'timestamptz';
 export declare function isTemporalType(s: string): s is TemporalFieldType;
-export type CastType = 'string' | 'number' | TemporalFieldType | 'boolean' | 'json';
-export type AtomicFieldType = CastType | 'sql native' | 'record' | 'array' | 'error';
+export type BasicAtomicType = 'string' | 'number' | TemporalFieldType | 'boolean' | 'json' | 'sql native' | 'error';
+export declare function isBasicAtomicType(s: string): s is BasicAtomicType;
+export type AtomicFieldType = BasicAtomicType | 'record' | 'array';
 export declare function isAtomicFieldType(s: string): s is AtomicFieldType;
 export declare function canOrderBy(s: string): boolean;
-export declare function isCastType(s: string): s is CastType;
 /**
  * Fields which contain scalar data all inherit from this. The field
  * value could be an expression, and this is one of the objects
@@ -460,6 +460,7 @@ export interface BasicArrayDef extends BasicArrayTypeDef, StructDefBase, JoinBas
  */
 export declare function mkFieldDef(atd: AtomicTypeDef, name: string): AtomicFieldDef;
 export declare function mkArrayDef(ofType: AtomicTypeDef, name: string): ArrayDef;
+export declare function mkArrayTypeDef(ofType: AtomicTypeDef): BasicArrayTypeDef | RepeatedRecordTypeDef;
 export interface RecordTypeDef {
     type: 'record';
     fields: FieldDef[];
@@ -982,20 +983,22 @@ export interface ModelAnnotation extends Annotation {
 }
 export type QueryScalar = string | boolean | number | bigint | Date | Buffer | null;
 /** One value in one column of returned data. */
-export type QueryValue = QueryScalar | QueryData | QueryDataRow;
+export type QueryValue = QueryScalar | QueryData | QueryRecord | QueryValue[];
 /** A row of returned data. */
-export type QueryDataRow = {
+export type QueryRecord = {
     [columnName: string]: QueryValue;
 };
 /** Returned query data. */
-export type QueryData = QueryDataRow[];
+export type QueryData = QueryRecord[];
+/** Type guard: is this array value compound (array of records) vs basic (array of scalars)? */
+export declare function isCompoundArrayData(v: QueryValue): v is QueryData;
 /** Query execution stats. */
 export type QueryRunStats = {
     queryCostBytes?: number;
 };
 /** Returned Malloy query data */
 export type MalloyQueryData = {
-    rows: QueryDataRow[];
+    rows: QueryRecord[];
     totalRows: number;
     runStats?: QueryRunStats;
     profilingUrl?: string;

package/dist/model/malloy_types.js

@@ -45,12 +45,13 @@ exports.maxExpressionType = maxExpressionType;
 exports.maxOfExpressionTypes = maxOfExpressionTypes;
 exports.hasExpression = hasExpression;
 exports.isTemporalType = isTemporalType;
+exports.isBasicAtomicType = isBasicAtomicType;
 exports.isAtomicFieldType = isAtomicFieldType;
 exports.canOrderBy = canOrderBy;
-exports.isCastType = isCastType;
 exports.fieldIsIntrinsic = fieldIsIntrinsic;
 exports.mkFieldDef = mkFieldDef;
 exports.mkArrayDef = mkArrayDef;
+exports.mkArrayTypeDef = mkArrayTypeDef;
 exports.isRepeatedRecordFunctionParam = isRepeatedRecordFunctionParam;
 exports.isRepeatedRecord = isRepeatedRecord;
 exports.isRecordOrRepeatedRecord = isRecordOrRepeatedRecord;
@@ -86,6 +87,7 @@ exports.isLiteral = isLiteral;
 exports.mergeEvalSpaces = mergeEvalSpaces;
 exports.isBasicAtomic = isBasicAtomic;
 exports.getIdentifier = getIdentifier;
+exports.isCompoundArrayData = isCompoundArrayData;
 exports.isTurtle = isTurtle;
 exports.isAtomic = isAtomic;
 exports.isValueString = isValueString;
@@ -232,7 +234,7 @@ function hasExpression(f) {
 function isTemporalType(s) {
     return s === 'date' || s === 'timestamp' || s === 'timestamptz';
 }
-function isAtomicFieldType(s) {
+function isBasicAtomicType(s) {
     return [
         'string',
         'number',
@@ -242,11 +244,12 @@ function isAtomicFieldType(s) {
         'boolean',
         'json',
         'sql native',
-        'record',
-        'array',
         'error',
     ].includes(s);
 }
+function isAtomicFieldType(s) {
+    return isBasicAtomicType(s) || s === 'record' || s === 'array';
+}
 function canOrderBy(s) {
     return [
         'string',
@@ -258,17 +261,6 @@ function canOrderBy(s) {
         'timestamptz',
     ].includes(s);
 }
-function isCastType(s) {
-    return [
-        'string',
-        'number',
-        'date',
-        'timestamp',
-        'timestamptz',
-        'boolean',
-        'json',
-    ].includes(s);
-}
 // this field definition represents something in the database.
 function fieldIsIntrinsic(f) {
     return isAtomicFieldType(f.type) && !hasExpression(f);
@@ -340,6 +332,16 @@ function mkArrayDef(ofType, name) {
         ],
     };
 }
+function mkArrayTypeDef(ofType) {
+    if (ofType.type === 'record') {
+        return {
+            type: 'array',
+            elementTypeDef: { type: 'record_element' },
+            fields: ofType.fields,
+        };
+    }
+    return { type: 'array', elementTypeDef: ofType };
+}
 function isRepeatedRecordFunctionParam(paramT) {
     return (paramT.type === 'array' && paramT.elementTypeDef.type === 'record_element');
 }
@@ -511,6 +513,12 @@ function getIdentifier(n) {
     }
     return n.name;
 }
+/** Type guard: is this array value compound (array of records) vs basic (array of scalars)? */
+function isCompoundArrayData(v) {
+    return (Array.isArray(v) &&
+        (v.length === 0 ||
+            (typeof v[0] === 'object' && v[0] !== null && !Array.isArray(v[0]))));
+}
 function isTurtle(def) {
     return def.type === 'turtle';
 }

package/dist/model/utils.d.ts

@@ -23,19 +23,17 @@ export declare class AndChain {
 }
 export declare function generateHash(input: string): string;
 /**
- * Compute a digest for lookup/identity purposes (not cryptographic).
+ * Compute a digest for lookup/identity purposes.
  *
- * Uses blueimp-md5 for these reasons:
+ * Uses @noble/hashes sha256:
  * - Works in both Node.js and browsers (no native crypto dependency)
  * - Synchronous API (unlike Web Crypto which is async)
- * - Well-maintained by Sebastian Tschan (blueimp), a known maintainer
- * - High adoption (~1.7M weekly downloads)
- * - MD5 is fast and produces short hex strings - perfect for cache keys
+ * - SHA-256 is appropriate since inputs may contain connection credentials
  *
  * Takes variable string arguments and combines them in a collision-resistant
  * way by including the length of each string (similar to pathToKey pattern).
  */
-export declare function makeDigest(...parts: string[]): string;
+export declare function makeDigest(...parts: (string | undefined)[]): string;
 export declare function joinWith<T>(els: T[][], sep: T): T[];
 export declare function range(start: number, end: number): number[];
 export declare function exprKids(eNode: Expr): IterableIterator<Expr>;

package/dist/model/utils.js

@@ -21,9 +21,6 @@
  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateState = exports.AndChain = void 0;
 exports.indent = indent;
@@ -42,7 +39,8 @@ exports.groupingKey = groupingKey;
 exports.caseGroup = caseGroup;
 exports.mkModelDef = mkModelDef;
 const uuid_1 = require("uuid");
-const blueimp_md5_1 = __importDefault(require("blueimp-md5"));
+const sha256_1 = require("@noble/hashes/sha256");
+const utils_1 = require("@noble/hashes/utils");
 const malloy_types_1 = require("./malloy_types");
 /** simple indent function */
 function indent(s) {
@@ -115,14 +113,12 @@ function generateHash(input) {
     return (0, uuid_1.v5)(input, MALLOY_UUID);
 }
 /**
- * Compute a digest for lookup/identity purposes (not cryptographic).
+ * Compute a digest for lookup/identity purposes.
  *
- * Uses blueimp-md5 for these reasons:
+ * Uses @noble/hashes sha256:
  * - Works in both Node.js and browsers (no native crypto dependency)
  * - Synchronous API (unlike Web Crypto which is async)
- * - Well-maintained by Sebastian Tschan (blueimp), a known maintainer
- * - High adoption (~1.7M weekly downloads)
- * - MD5 is fast and produces short hex strings - perfect for cache keys
+ * - SHA-256 is appropriate since inputs may contain connection credentials
  *
  * Takes variable string arguments and combines them in a collision-resistant
  * way by including the length of each string (similar to pathToKey pattern).
@@ -131,8 +127,11 @@ function makeDigest(...parts) {
     // Combine parts with length prefix to avoid collisions
     // e.g., ("ab", "c") vs ("a", "bc") both concat to "abc"
     // but with lengths: "2:ab/1:c" vs "1:a/2:bc"
-    const combined = parts.map(p => `${p.length}:${p}`).join('/');
-    return (0, blueimp_md5_1.default)(combined);
+    // undefined is distinct from empty string in the hash
+    const combined = parts
+        .map(p => (p === undefined ? '{undefined}' : `${p.length}:${p}`))
+        .join('/');
+    return (0, utils_1.bytesToHex)((0, sha256_1.sha256)(combined));
 }
 function joinWith(els, sep) {
     const result = [];

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.337";
+export declare const MALLOY_VERSION = "0.0.339";

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.337';
+exports.MALLOY_VERSION = '0.0.339';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.337",
+  "version": "0.0.339",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -45,12 +45,12 @@
     "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.337",
-    "@malloydata/malloy-interfaces": "0.0.337",
-    "@malloydata/malloy-tag": "0.0.337",
+    "@malloydata/malloy-filter": "0.0.339",
+    "@malloydata/malloy-interfaces": "0.0.339",
+    "@malloydata/malloy-tag": "0.0.339",
+    "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
-    "blueimp-md5": "^2.19.0",
     "jaro-winkler": "^0.2.8",
     "jest-diff": "^29.6.2",
     "lodash": "^4.17.20",
@@ -58,7 +58,6 @@
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@types/blueimp-md5": "^2.18.2",
     "@types/jaro-winkler": "^0.2.3",
     "@types/lodash": "^4.14.165",
     "@types/luxon": "^3.5.0",