@malloydata/malloy 0.0.393 → 0.0.394

package/dist/api/foundation/core.d.ts

@@ -278,10 +278,6 @@ export declare class Model implements Taggable {
      * The givens this model surfaces, keyed by caller-facing surface name.
      * Used by whole-model parameter-editor UIs to render input widgets for
      * every given the model can accept.
-     *
-     * Internal-only givens (declared but never surfaced into the namespace,
-     * resolved purely via defaults) are NOT in this map — the caller has no
-     * way to set them, so listing them would mislead a UI.
      */
     get givens(): ReadonlyMap<string, Given>;
     tagParse(spec?: TagParseSpec): MalloyTagParse;

package/dist/api/foundation/core.js

@@ -782,10 +782,6 @@ class Model {
      * The givens this model surfaces, keyed by caller-facing surface name.
      * Used by whole-model parameter-editor UIs to render input widgets for
      * every given the model can accept.
-     *
-     * Internal-only givens (declared but never surfaced into the namespace,
-     * resolved purely via defaults) are NOT in this map — the caller has no
-     * way to set them, so listing them would mislead a UI.
      */
     get givens() {
         var _a, _b;
@@ -799,9 +795,9 @@ class Model {
             if ((_b = (_a = this.runtimeContext) === null || _a === void 0 ? void 0 : _a.finalizedGivens) === null || _b === void 0 ? void 0 : _b.has(surfaceName))
                 continue;
             const decl = givens[entry.id];
-            if (!decl)
-                continue;
-            out.set(surfaceName, new Given(surfaceName, entry.id, decl));
+            if (decl && !decl.inline) {
+                out.set(surfaceName, new Given(surfaceName, entry.id, decl));
+            }
         }
         return out;
     }
@@ -1197,11 +1193,18 @@ class PreparedQuery {
      */
     getPreparedResult(options) {
         const queryModel = this._model.queryModel;
+        // Build the resolved-givens map in two phases:
+        //   1. caller-supplied values (resolveSuppliedGivens)
+        //   2. inline-given defaults eager-evaluated against the map
+        // Result is undefined when no values land — preserves the previous
+        // "no givens path" downstream.
+        const resolved = (options === null || options === void 0 ? void 0 : options.givens)
+            ? (0, given_binding_1.resolveSuppliedGivens)(options.givens, this._modelDef)
+            : new Map();
+        (0, given_binding_1.evaluateInlineGivens)(resolved, this._modelDef);
         const prepareResultOptions = {
             ...options,
-            resolvedGivens: (options === null || options === void 0 ? void 0 : options.givens)
-                ? (0, given_binding_1.resolveSuppliedGivens)(options.givens, this._modelDef)
-                : undefined,
+            resolvedGivens: resolved.size > 0 ? resolved : undefined,
         };
         const translatedQuery = queryModel.compileQuery(this._query, prepareResultOptions);
         return new PreparedResult({

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

@@ -3,6 +3,7 @@ import type { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
 import type { FieldSpace } from '../types/field-space';
 import { BinaryBoolean } from './binary-boolean';
+import type { GivenReference } from './expr-given';
 export declare class ExprCompare extends BinaryBoolean<CompareMalloyOperator> {
     elementType: string;
     constructor(left: ExpressionDef, op: CompareMalloyOperator, right: ExpressionDef);
@@ -28,3 +29,17 @@ export declare class ExprLegacyIn extends ExpressionDef {
     constructor(expr: ExpressionDef, notIn: boolean, choices: ExpressionDef[]);
     getExpression(fs: FieldSpace): ExprValue;
 }
+/**
+ * `expr in $ARRAY_GIVEN` — runtime test of a basic-typed expression
+ * against the elements of a runtime-bound array given. The translator
+ * verifies the given is `T[]` and the LHS is the same basic `T`; SQL
+ * emission expands the bound array's elements at compile time.
+ */
+export declare class ExprInGiven extends ExpressionDef {
+    readonly expr: ExpressionDef;
+    readonly notIn: boolean;
+    readonly givenRef: GivenReference;
+    elementType: string;
+    constructor(expr: ExpressionDef, notIn: boolean, givenRef: GivenReference);
+    getExpression(fs: FieldSpace): ExprValue;
+}

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

@@ -55,9 +55,12 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+exports.ExprInGiven = exports.ExprLegacyIn = exports.ExprEquality = exports.ExprCompare = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const utils_1 = require("../../../model/utils");
 const TDU = __importStar(require("../typedesc-utils"));
 const expr_value_1 = require("../types/expr-value");
+const expr_value_2 = require("../types/expr-value");
 const expression_def_1 = require("../types/expression-def");
 const binary_boolean_1 = require("./binary-boolean");
 const compareTypes = {
@@ -112,7 +115,7 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     getExpression(fs) {
         const lookFor = this.expr.getExpression(fs);
         const oneOf = this.choices.map(e => e.getExpression(fs));
-        return (0, expr_value_1.computedExprValue)({
+        return (0, expr_value_2.computedExprValue)({
             dataType: { type: 'boolean' },
             value: {
                 node: 'in',
@@ -124,4 +127,81 @@ class ExprLegacyIn extends expression_def_1.ExpressionDef {
     }
 }
 exports.ExprLegacyIn = ExprLegacyIn;
+/**
+ * `expr in $ARRAY_GIVEN` — runtime test of a basic-typed expression
+ * against the elements of a runtime-bound array given. The translator
+ * verifies the given is `T[]` and the LHS is the same basic `T`; SQL
+ * emission expands the bound array's elements at compile time.
+ */
+class ExprInGiven extends expression_def_1.ExpressionDef {
+    constructor(expr, notIn, givenRef) {
+        super();
+        this.expr = expr;
+        this.notIn = notIn;
+        this.givenRef = givenRef;
+        this.elementType = 'inGiven';
+        this.has({ expr, givenRef });
+    }
+    getExpression(fs) {
+        const lookFor = this.expr.getExpression(fs);
+        const givenVal = this.givenRef.getExpression(fs);
+        // `in` is logically a boolean — every error path returns a
+        // boolean-typed error so a `where:` clause around us doesn't pile a
+        // "filter must be boolean" complaint on top of our own diagnostic.
+        const boolError = () => (0, expr_value_1.computedErrorExprValue)({
+            dataType: { type: 'boolean' },
+            error: 'in-given type error',
+            from: [lookFor, givenVal],
+        });
+        if (lookFor.type === 'error' || givenVal.type === 'error') {
+            return boolError();
+        }
+        // GivenReference only ever returns a `given` ExprValue on the
+        // success path; the error branch is filtered above. No other case
+        // is reachable here.
+        const givenNode = givenVal.value;
+        if (givenNode.node !== 'given') {
+            throw this.internalError(`expected GivenReference to produce a 'given' node, got '${givenNode.node}'`);
+        }
+        if (!malloy_types_1.TD.isAtomic(givenVal) || givenVal.type !== 'array') {
+            this.logError('in-given-rhs-not-array', {
+                givenName: this.givenRef.name,
+                actualType: malloy_types_1.TD.isAtomic(givenVal)
+                    ? (0, utils_1.typeDefToString)(givenVal)
+                    : givenVal.type,
+            });
+            return boolError();
+        }
+        if ((0, malloy_types_1.isRepeatedRecord)(givenVal)) {
+            this.logError('in-given-rhs-not-basic-array', {
+                givenName: this.givenRef.name,
+                elementType: (0, utils_1.typeDefToString)(givenVal),
+            });
+            return boolError();
+        }
+        // givenVal is BasicArrayTypeDef-shaped — the union for array
+        // AtomicTypeDefs is BasicArray | RepeatedRecord, and the
+        // RepeatedRecord branch returned above.
+        const elemType = givenVal.elementTypeDef;
+        if (!malloy_types_1.TD.isBasicAtomic(lookFor) || lookFor.type !== elemType.type) {
+            this.logError('in-given-type-mismatch', {
+                lhsType: malloy_types_1.TD.isAtomic(lookFor) ? (0, utils_1.typeDefToString)(lookFor) : lookFor.type,
+                elementType: (0, utils_1.typeDefToString)(elemType),
+            });
+            return boolError();
+        }
+        const inGivenNode = {
+            node: 'inGiven',
+            not: this.notIn,
+            givenRef: givenNode,
+            e: lookFor.value,
+        };
+        return (0, expr_value_2.computedExprValue)({
+            dataType: { type: 'boolean' },
+            value: inGivenNode,
+            from: [lookFor, givenVal],
+        });
+    }
+}
+exports.ExprInGiven = ExprInGiven;
 //# sourceMappingURL=expr-compare.js.map

package/dist/lang/ast/statements/define-given.d.ts

@@ -7,12 +7,13 @@ import { extendNoteMethod } from '../types/noteable';
 export declare class GivenDeclaration extends MalloyElement implements DocStatement, Noteable {
     readonly name: string;
     readonly typeDef: GivenTypeDef;
+    readonly inline: boolean;
     elementType: string;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     note?: Annotation;
     readonly default?: ConstantExpression;
-    constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression);
+    constructor(name: string, typeDef: GivenTypeDef, defaultExpr?: ConstantExpression, inline?: boolean);
     protected varInfo(): string;
     execute(doc: Document): void;
 }

package/dist/lang/ast/statements/define-given.js

@@ -6,6 +6,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefineGivens = exports.GivenDeclaration = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
+const inline_expr_1 = require("../../../model/inline_expr");
 const source_def_utils_1 = require("../../../model/source_def_utils");
 const utils_1 = require("../../../model/utils");
 const expression_def_1 = require("../types/expression-def");
@@ -20,11 +21,43 @@ function filterTypeMismatch(declared, constVal) {
     return ((declared.type === 'filter expression') !==
         (constVal.type === 'filter expression'));
 }
+/**
+ * Walk an Expr tree and collect every node string that isn't in the
+ * allowed inline operator/leaf sets.
+ *
+ * The translator caller is gated on a clean translation of the default
+ * (`constVal.type !== 'error'`): we don't pile bad-operator errors on
+ * top of a default that didn't translate cleanly for more fundamental
+ * reasons (an unknown `$REF`, a type mismatch, etc.). Every bad node
+ * is collected so the author sees the full list in one diagnostic.
+ */
+function collectInlineBadOps(e, bad) {
+    if (!inline_expr_1.INLINE_OPS.has(e.node) && !inline_expr_1.INLINE_LEAVES.has(e.node)) {
+        bad.add(e.node);
+    }
+    if ((0, malloy_types_1.exprHasE)(e)) {
+        collectInlineBadOps(e.e, bad);
+    }
+    else if ((0, malloy_types_1.exprHasKids)(e)) {
+        for (const kid of Object.values(e.kids)) {
+            if (kid === null)
+                continue;
+            if (Array.isArray(kid)) {
+                for (const k of kid)
+                    collectInlineBadOps(k, bad);
+            }
+            else {
+                collectInlineBadOps(kid, bad);
+            }
+        }
+    }
+}
 class GivenDeclaration extends malloy_element_1.MalloyElement {
-    constructor(name, typeDef, defaultExpr) {
+    constructor(name, typeDef, defaultExpr, inline = false) {
         super();
         this.name = name;
         this.typeDef = typeDef;
+        this.inline = inline;
         this.elementType = 'given';
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
@@ -44,6 +77,12 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             this.logError('given-definition-name-conflict', `Cannot redefine '${this.name}'`);
             return;
         }
+        // An inline given with no default has nothing to evaluate at bind
+        // time. Log and keep going — the given still registers in the
+        // namespace so downstream errors don't cascade pointlessly.
+        if (this.inline && !this.default) {
+            this.logError('inline-no-default', { name: this.name });
+        }
         // Default expression. ConstantExpression evaluates through a
         // ConstantFieldSpace that errors on every name lookup, so any
         // non-constant subexpression (field refs, aggregates, etc.) gets
@@ -112,6 +151,17 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
                     }
                     givenUsage = closure;
                 }
+                // Ensure inline expression is resolveable at compile time.
+                if (this.inline) {
+                    const bad = new Set();
+                    collectInlineBadOps(defaultExpr, bad);
+                    if (bad.size > 0) {
+                        this.default.logError('inline-bad-operator', {
+                            name: this.name,
+                            operators: [...bad].sort().join(', '),
+                        });
+                    }
+                }
             }
         }
         const id = (0, source_def_utils_1.mkGivenID)(this.name, (_c = this.location) === null || _c === void 0 ? void 0 : _c.url);
@@ -124,6 +174,7 @@ class GivenDeclaration extends malloy_element_1.MalloyElement {
             givenUsage,
             location: this.location,
             annotation: this.note,
+            ...(this.inline ? { inline: true } : {}),
         };
         doc.documentGivens.set(id, givenIR);
         const entry = { type: 'given', name: this.name, id };

package/dist/lang/ast/types/malloy-element.js

@@ -239,10 +239,12 @@ class MalloyElement {
             const kiddle = this.children[kidLabel];
             if (kiddle instanceof MalloyElement) {
                 yield kiddle;
+                yield* kiddle.walk();
             }
             else {
                 for (const k of kiddle) {
                     yield k;
+                    yield* k.walk();
                 }
             }
         }