@malloydata/malloy 0.0.432 → 0.0.434

package/dist/lang/ast/field-space/index-field-space.js

@@ -12,7 +12,6 @@ const field_references_1 = require("../query-items/field-references");
 const space_field_1 = require("../types/space-field");
 const query_spaces_1 = require("./query-spaces");
 const reference_field_1 = require("./reference-field");
-const static_space_1 = require("./static-space");
 class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
     constructor() {
         super(...arguments);
@@ -81,46 +80,21 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
     }
     addRefineFromFields(_refineThis) { }
     addWild(wild) {
-        var _a, _b;
-        let current = this.exprSpace;
-        const joinPath = [];
-        if (wild.joinPath) {
-            // walk path to determine namespace for *
-            for (const pathPart of wild.joinPath.list) {
-                const part = pathPart.refString;
-                joinPath.push(part);
-                const ent = current.entry(part);
-                if (ent) {
-                    if (ent instanceof static_space_1.StructSpaceField) {
-                        current = ent.fieldSpace;
-                    }
-                    else {
-                        pathPart.logError('invalid-wildcard-source', `Field '${part}' does not contain rows and cannot be expanded with '*'`);
-                        return;
-                    }
-                }
-                else {
-                    pathPart.logError('wildcard-source-not-found', `No such field as '${part}'`);
-                    return;
-                }
-            }
+        var _a, _b, _c, _d;
+        const entries = this.wildcardExpansion(wild);
+        if (entries === undefined) {
+            return;
         }
+        const joinPath = (_b = (_a = wild.joinPath) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : [];
         const dialect = this.dialectObj();
         const expandEntries = [];
-        for (const [name, entry] of current.entries()) {
-            if (wild.except.has(name)) {
-                continue;
-            }
-            if (entry.refType === 'parameter') {
-                continue;
-            }
+        for (const [name, entry] of entries) {
             const indexName = field_references_1.IndexFieldReference.indexOutputName([
                 ...joinPath,
                 name,
             ]);
             if (this.entry(indexName)) {
-                const conflict = (_b = (_a = this.expandedWild.get(indexName)) === null || _a === void 0 ? void 0 : _a.path) === null || _b === void 0 ? void 0 : _b.join('.');
-                wild.logError('name-conflict-in-wildcard-expansion', `Cannot expand '${name}' in '${wild.refString}' because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
+                this.logWildcardConflict(wild, name, (_d = (_c = this.expandedWild.get(indexName)) === null || _c === void 0 ? void 0 : _c.path) === null || _d === void 0 ? void 0 : _d.join('.'));
             }
             else {
                 const eTypeDesc = entry.typeDesc();

package/dist/lang/ast/field-space/parameter-space.js

@@ -41,6 +41,7 @@ class ParameterSpace {
                 error: {
                     message: `\`${name}\` is not defined`,
                     code: 'parameter-not-found',
+                    at: name,
                 },
                 found: undefined,
             };
@@ -52,6 +53,7 @@ class ParameterSpace {
                         .slice(1)
                         .join('.')}\``,
                     code: 'invalid-parameter-reference',
+                    at: name,
                 },
                 found: undefined,
             };

package/dist/lang/ast/field-space/query-spaces.d.ts

@@ -57,6 +57,16 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     inputSpace(): QueryInputSpace;
     outputSpace(): QueryOperationSpace;
     isQueryOutputSpace(): boolean;
+    protected logWildcardConflict(wild: WildcardFieldReference, name: string, conflict: string | undefined): void;
+    /**
+     * A `*` expands the fields a user of the finished source will see: it
+     * walks its path and reads the namespace at the end as a public reader,
+     * with the same walk and the same per-entry rule as a lookup by name.
+     * A disallowed path is an error, since the user wrote it; a disallowed
+     * field is dropped, since naming it would disclose it. Returns undefined,
+     * having logged, when the path fails or nothing is left to expand.
+     */
+    protected wildcardExpansion(wild: WildcardFieldReference): [string, SpaceEntry][] | undefined;
     protected addWild(wild: WildcardFieldReference): void;
     protected addValidatedCompositeFieldUserFromEntry(name: string, entry: SpaceEntry): void;
     addFieldUserFromFilter(filter: model.FilterCondition): void;

package/dist/lang/ast/field-space/query-spaces.js

@@ -114,43 +114,44 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
     isQueryOutputSpace() {
         return true;
     }
+    logWildcardConflict(wild, name, conflict) {
+        wild.logError('name-conflict-in-wildcard-expansion', `Cannot expand '${name}' in '${wild.refString}' because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
+    }
+    /**
+     * A `*` expands the fields a user of the finished source will see: it
+     * walks its path and reads the namespace at the end as a public reader,
+     * with the same walk and the same per-entry rule as a lookup by name.
+     * A disallowed path is an error, since the user wrote it; a disallowed
+     * field is dropped, since naming it would disclose it. Returns undefined,
+     * having logged, when the path fails or nothing is left to expand.
+     */
+    wildcardExpansion(wild) {
+        var _a, _b, _c;
+        const ns = (0, static_space_1.resolveNamespace)(this.exprSpace, (_b = (_a = wild.joinPath) === null || _a === void 0 ? void 0 : _a.list) !== null && _b !== void 0 ? _b : [], 'public', '*');
+        if (ns.error) {
+            const at = (_c = ns.error.at) !== null && _c !== void 0 ? _c : wild;
+            at.logError(ns.error.code, ns.error.message);
+            return undefined;
+        }
+        const entries = (0, static_space_1.accessibleEntries)(ns.space, ns.accessLevel).filter(([name, entry]) => !wild.except.has(name) && entry.refType !== 'parameter');
+        if (entries.length === 0) {
+            wild.logError('wildcard-matched-no-fields', `'${wild.refString}' did not match any fields`);
+            return undefined;
+        }
+        return entries;
+    }
     addWild(wild) {
-        var _a;
-        let current = this.exprSpace;
-        const joinPath = [];
-        if (wild.joinPath) {
-            // walk path to determine namespace for *
-            for (const pathPart of wild.joinPath.list) {
-                const part = pathPart.refString;
-                joinPath.push(part);
-                const ent = current.entry(part);
-                if (ent) {
-                    if (ent instanceof static_space_1.StructSpaceField) {
-                        current = ent.fieldSpace;
-                    }
-                    else {
-                        pathPart.logError('invalid-wildcard-source', `Field '${part}' does not contain rows and cannot be expanded with '*'`);
-                        return;
-                    }
-                }
-                else {
-                    pathPart.logError('wildcard-source-not-defined', `No such field as '${part}'`);
-                    return;
-                }
-            }
+        var _a, _b, _c;
+        const entries = this.wildcardExpansion(wild);
+        if (entries === undefined) {
+            return;
         }
+        const joinPath = (_b = (_a = wild.joinPath) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : [];
         const dialect = this.dialectObj();
         const expandEntries = [];
-        for (const [name, entry] of current.entries()) {
-            if (wild.except.has(name)) {
-                continue;
-            }
-            if (entry.refType === 'parameter') {
-                continue;
-            }
+        for (const [name, entry] of entries) {
             if (this.entry(name)) {
-                const conflict = (_a = this.expandedWild.get(name)) === null || _a === void 0 ? void 0 : _a.path.join('.');
-                wild.logError('name-conflict-in-wildcard-expansion', `Cannot expand '${name}' in '${wild.refString}' because a field with that name already exists${conflict ? ` (conflicts with ${conflict})` : ''}`);
+                this.logWildcardConflict(wild, name, (_c = this.expandedWild.get(name)) === null || _c === void 0 ? void 0 : _c.path.join('.'));
             }
             else {
                 const eType = entry.typeDesc();

package/dist/lang/ast/field-space/static-space.d.ts

@@ -1,7 +1,7 @@
 import type { Dialect } from '../../../dialect/dialect';
 import type { FieldDef, StructDef, SourceDef, JoinFieldDef, AccessModifierLabel } from '../../../model/malloy_types';
 import type { SpaceEntry } from '../types/space-entry';
-import type { LookupResult } from '../types/lookup-result';
+import type { JoinPath, LookupError, LookupResult } from '../types/lookup-result';
 import type { FieldName, FieldSpace, QueryFieldSpace, SourceFieldSpace } from '../types/field-space';
 import { SpaceField } from '../types/space-field';
 import { StructSpaceFieldBase } from './struct-space-field-base';
@@ -50,3 +50,36 @@ export declare class StaticSourceSpace extends StaticSpace implements SourceFiel
     emptyStructDef(): SourceDef;
     accessProtectionLevel(): AccessModifierLabel;
 }
+/**
+ * A namespace reached by walking a join path, and the access level a reader
+ * who started at `accessLevel` has once they arrive there.
+ */
+export interface NamespaceRead {
+    space: FieldSpace;
+    accessLevel: AccessModifierLabel;
+    joinPath: JoinPath;
+    error: undefined;
+}
+/**
+ * Walk `path` from `from`, one `readEntry` per hop, narrowing the access
+ * level at each join. `lookup()` walks the path before a name with it and
+ * `*` walks the path before a star. `member` is what is about to be read from the namespace at the end
+ * of the path, a field name or `'*'`, named in the error when a hop is not a
+ * namespace.
+ */
+export declare function resolveNamespace(from: FieldSpace, path: FieldName[], accessLevel: AccessModifierLabel, member: string): NamespaceRead | LookupError;
+interface EntryRead {
+    found: SpaceEntry;
+    error: undefined;
+}
+/**
+ * Read one name from a namespace on behalf of a reader at `accessLevel`.
+ * Records the reference, and refuses the entry if the reader may not see it.
+ */
+export declare function readEntry(space: FieldSpace, name: FieldName, accessLevel: AccessModifierLabel): EntryRead | LookupError;
+/**
+ * Every entry of `space` a reader at `accessLevel` may see, by the same
+ * rule `readEntry` applies to one name.
+ */
+export declare function accessibleEntries(space: FieldSpace, accessLevel: AccessModifierLabel): [string, SpaceEntry][];
+export {};

package/dist/lang/ast/field-space/static-space.js

@@ -5,6 +5,9 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StaticSourceSpace = exports.StructSpaceField = exports.StaticSpace = void 0;
+exports.resolveNamespace = resolveNamespace;
+exports.readEntry = readEntry;
+exports.accessibleEntries = accessibleEntries;
 const dialect_map_1 = require("../../../dialect/dialect_map");
 const malloy_types_1 = require("../../../model/malloy_types");
 const field_space_1 = require("../types/field-space");
@@ -107,81 +110,19 @@ class StaticSpace {
     }
     lookup(path, accessLevel) {
         accessLevel !== null && accessLevel !== void 0 ? accessLevel : (accessLevel = this.accessProtectionLevel());
-        const head = path[0];
-        const rest = path.slice(1);
-        let found = this.entry(head.refString);
-        if (!found) {
-            return {
-                error: {
-                    message: `'${head}' is not defined`,
-                    code: 'field-not-found',
-                },
-                found,
-            };
+        const last = path[path.length - 1];
+        const ns = resolveNamespace(this, path.slice(0, -1), accessLevel, last.refString);
+        if (ns.error) {
+            return ns;
         }
-        if (found instanceof space_field_1.SpaceField) {
-            const definition = found.fieldDef();
-            if (definition) {
-                if (!(found instanceof struct_space_field_base_1.StructSpaceFieldBase) && (0, malloy_types_1.isJoined)(definition)) {
-                    // We have looked up a field which is a join, but not a StructSpaceField
-                    // because it is someting like "dimension: joinedArray is arrayComputation"
-                    // which wasn't known to be a join when the fieldspace was constructed.
-                    // TODO don't make one of these every time you do a lookup
-                    found = new StructSpaceField(definition, this.structDialect, this.structConnection);
-                }
-                // cswenson review todo I don't know how to count the reference properly now
-                // i tried only writing it as a join reference if there was more in the path
-                // but that failed because lookup([JOINNAME]) is called when translating JOINNAME.AGGREGATE(...)
-                // with a 1-length-path but that IS a join reference and there is a test
-                head.addReference({
-                    type: found instanceof struct_space_field_base_1.StructSpaceFieldBase
-                        ? 'joinReference'
-                        : 'fieldReference',
-                    definition: {
-                        type: definition.type,
-                        annotations: definition.annotations,
-                        location: definition.location,
-                    },
-                    location: head.location,
-                    text: head.refString,
-                });
-            }
-            if (definition === null || definition === void 0 ? void 0 : definition.accessModifier) {
-                if (!accessAllowed(accessLevel, definition.accessModifier)) {
-                    return {
-                        error: {
-                            message: `'${head}' is ${definition === null || definition === void 0 ? void 0 : definition.accessModifier}`,
-                            code: 'field-not-accessible',
-                        },
-                        found: undefined,
-                    };
-                }
-            }
-        } // cswenson review todo { else this is SpaceEntry not a field which can only be a param and what is going on? }
-        const joinPath = found instanceof struct_space_field_base_1.StructSpaceFieldBase
-            ? [{ ...found.joinPathElement, name: head.refString }]
-            : [];
-        if (rest.length) {
-            if (found instanceof struct_space_field_base_1.StructSpaceFieldBase) {
-                const restResult = found.fieldSpace.lookup(rest, lessPermissiveAccessLevel(accessLevel, found.fieldSpace.accessProtectionLevel()));
-                if (restResult.found) {
-                    return {
-                        ...restResult,
-                        joinPath: [...joinPath, ...restResult.joinPath],
-                    };
-                }
-                else {
-                    return restResult;
-                }
-            }
-            return {
-                error: {
-                    message: `'${head}' cannot contain a '${rest[0]}'`,
-                    code: 'invalid-property-access-in-field-reference',
-                },
-                found: undefined,
-            };
+        const read = readEntry(ns.space, last, ns.accessLevel);
+        if (read.error) {
+            return read;
         }
+        const found = read.found;
+        const joinPath = found instanceof struct_space_field_base_1.StructSpaceFieldBase
+            ? [...ns.joinPath, { ...found.joinPathElement, name: last.refString }]
+            : ns.joinPath;
         return { found, error: undefined, joinPath, isOutputField: false };
     }
     isQueryFieldSpace() {
@@ -225,9 +166,111 @@ class StaticSourceSpace extends StaticSpace {
     }
 }
 exports.StaticSourceSpace = StaticSourceSpace;
+/**
+ * Walk `path` from `from`, one `readEntry` per hop, narrowing the access
+ * level at each join. `lookup()` walks the path before a name with it and
+ * `*` walks the path before a star. `member` is what is about to be read from the namespace at the end
+ * of the path, a field name or `'*'`, named in the error when a hop is not a
+ * namespace.
+ */
+function resolveNamespace(from, path, accessLevel, member) {
+    let space = from;
+    const joinPath = [];
+    for (let i = 0; i < path.length; i++) {
+        const hop = path[i];
+        const read = readEntry(space, hop, accessLevel);
+        if (read.error) {
+            return read;
+        }
+        if (!(read.found instanceof struct_space_field_base_1.StructSpaceFieldBase)) {
+            const next = i + 1 < path.length ? path[i + 1].refString : member;
+            const message = next === '*'
+                ? `'${hop}' does not contain fields and cannot be expanded with '*'`
+                : `'${hop}' cannot contain a '${next}'`;
+            return {
+                error: {
+                    message,
+                    code: 'invalid-property-access-in-field-reference',
+                    at: hop,
+                },
+                found: undefined,
+            };
+        }
+        joinPath.push({ ...read.found.joinPathElement, name: hop.refString });
+        space = read.found.fieldSpace;
+        accessLevel = lessPermissiveAccessLevel(accessLevel, space.accessProtectionLevel());
+    }
+    return { space, accessLevel, joinPath, error: undefined };
+}
+/**
+ * Read one name from a namespace on behalf of a reader at `accessLevel`.
+ * Records the reference, and refuses the entry if the reader may not see it.
+ */
+function readEntry(space, name, accessLevel) {
+    let found = space.entry(name.refString);
+    let restriction;
+    if (!found) {
+        return {
+            error: {
+                message: `'${name}' is not defined`,
+                code: 'field-not-found',
+                at: name,
+            },
+            found: undefined,
+        };
+    }
+    if (found instanceof space_field_1.SpaceField) {
+        const definition = found.fieldDef();
+        restriction = definition === null || definition === void 0 ? void 0 : definition.accessModifier;
+        if (definition) {
+            if (!(found instanceof struct_space_field_base_1.StructSpaceFieldBase) && (0, malloy_types_1.isJoined)(definition)) {
+                // A field which turned out to be a join after the space was built,
+                // e.g. "dimension: joinedArray is arrayComputation", so the entry
+                // is not a StructSpaceField; promote it so the path can continue.
+                found = new StructSpaceField(definition, space.dialectName(), space.connectionName());
+            }
+            // A one-element path to a join is still a join reference:
+            // JOIN.aggregate() looks the join up on its own.
+            name.addReference({
+                type: found instanceof struct_space_field_base_1.StructSpaceFieldBase
+                    ? 'joinReference'
+                    : 'fieldReference',
+                definition: {
+                    type: definition.type,
+                    annotations: definition.annotations,
+                    location: definition.location,
+                },
+                location: name.location,
+                text: name.refString,
+            });
+        }
+    }
+    if (restriction && !accessAllowed(accessLevel, restriction)) {
+        return {
+            error: {
+                message: `'${name}' is ${restriction}`,
+                code: 'field-not-accessible',
+                at: name,
+            },
+            found: undefined,
+        };
+    }
+    return { found, error: undefined };
+}
+/**
+ * Every entry of `space` a reader at `accessLevel` may see, by the same
+ * rule `readEntry` applies to one name.
+ */
+function accessibleEntries(space, accessLevel) {
+    return space.entries().filter(([, entry]) => {
+        var _a;
+        const restriction = entry instanceof space_field_1.SpaceField
+            ? (_a = entry.fieldDef()) === null || _a === void 0 ? void 0 : _a.accessModifier
+            : undefined;
+        return restriction === undefined || accessAllowed(accessLevel, restriction);
+    });
+}
 function accessAllowed(accessLevel, accessModifier) {
-    if (accessModifier === 'public')
-        return true;
     if (accessLevel === 'internal')
         return accessModifier === 'internal';
     if (accessLevel === 'private')

package/dist/lang/ast/source-elements/refined-source.js

@@ -81,7 +81,7 @@ class RefinedSource extends source_1.Source {
                 filters.push(el);
             }
             else if (el instanceof timezone_statement_1.TimezoneStatement) {
-                newTimezone = el.tz;
+                newTimezone = el.timezoneName();
             }
             else {
                 errTo.logError('unexpected-source-property', `Unexpected source property: '${errTo.elementType}'`);

package/dist/lang/ast/source-elements/sql-source.js

@@ -19,12 +19,13 @@ class SQLSource extends source_1.Source {
         this.connectionNameInvalid = false;
     }
     sqlSourceRequest(doc) {
+        var _a;
         const partialModel = this.select.containsQueries
             ? doc.modelDef()
             : undefined;
         const [valid, phrases] = this.select.sqlPhrases(this.connectionName.refString);
         if (valid) {
-            return (0, sql_block_1.getSourceRequest)(phrases, this.connectionName.refString, partialModel);
+            return (0, sql_block_1.getSourceRequest)(phrases, this.connectionName.refString, partialModel, (_a = this.translator()) === null || _a === void 0 ? void 0 : _a.root.virtualMap);
         }
         return undefined;
     }

package/dist/lang/ast/source-properties/timezone-statement.d.ts

@@ -1,12 +1,13 @@
+import type { ExprString } from '../expressions/expr-string';
 import type { QueryBuilder } from '../types/query-builder';
 import { MalloyElement } from '../types/malloy-element';
 import type { QueryPropertyInterface } from '../types/query-property-interface';
 export declare class TimezoneStatement extends MalloyElement implements QueryPropertyInterface {
-    readonly tz: string;
+    private readonly timezone;
     elementType: string;
     forceQueryClass: undefined;
     queryRefinementStage: undefined;
-    constructor(tz: string);
-    get isValid(): boolean;
+    constructor(timezone: ExprString);
+    timezoneName(): string | undefined;
     queryExecute(executeFor: QueryBuilder): void;
 }

package/dist/lang/ast/source-properties/timezone-statement.js

@@ -5,27 +5,29 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TimezoneStatement = void 0;
+const dialect_1 = require("../../../dialect/dialect");
 const malloy_element_1 = require("../types/malloy-element");
-const luxon_1 = require("luxon");
 class TimezoneStatement extends malloy_element_1.MalloyElement {
-    constructor(tz) {
-        super();
-        this.tz = tz;
+    constructor(timezone) {
+        super({ timezone });
+        this.timezone = timezone;
         this.elementType = 'timezone';
         this.forceQueryClass = undefined;
         this.queryRefinementStage = undefined;
     }
-    get isValid() {
-        try {
-            luxon_1.DateTime.fromISO('2020-02-19T00:00:00', { zone: this.tz });
-            return true;
-        }
-        catch {
-            return false;
+    timezoneName() {
+        const name = this.timezone.value;
+        if (!dialect_1.Dialect.isSafeTimezoneName(name)) {
+            this.logError('invalid-timezone', { timezone: name }, { at: this.timezone.location });
+            return undefined;
         }
+        return name;
     }
     queryExecute(executeFor) {
-        executeFor.resultFS.setTimezone(this.tz);
+        const timezone = this.timezoneName();
+        if (timezone !== undefined) {
+            executeFor.resultFS.setTimezone(timezone);
+        }
     }
 }
 exports.TimezoneStatement = TimezoneStatement;

package/dist/lang/ast/types/lookup-result.d.ts

@@ -1,6 +1,7 @@
 import type { JoinElementType, JoinType } from '../../../model';
 import type { MessageCode } from '../../parse-log';
 import type { SpaceEntry } from './space-entry';
+import type { FieldName } from './field-space';
 export interface JoinPathElement {
     name: string;
     joinElementType: JoinElementType;
@@ -17,6 +18,7 @@ export interface LookupError {
     error: {
         message: string;
         code: MessageCode;
+        at?: FieldName | undefined;
     };
     found: undefined;
 }

package/dist/lang/composite-source-utils.js

@@ -407,9 +407,11 @@ function expandRefUsage(seed, fields, alwaysJoinNames = []) {
     // given usage into the accumulator. Used both in-loop (joins reached
     // via reference paths) and upfront (always-on segment-level joins).
     function activateJoin(joinDef, joinPath) {
+        if (!(0, malloy_types_1.isJoined)(joinDef))
+            return;
         const joinKey = (0, utils_2.pathToKey)('join', joinPath);
         const thisDep = getJoin(activeJoinGraph, joinKey, joinPath);
-        if (!(0, malloy_types_1.isJoined)(joinDef) || thisDep.checked)
+        if (thisDep.checked)
             return;
         thisDep.checked = true;
         const joinFieldUsage = getJoinFieldUsage(joinDef, joinPath);
@@ -462,8 +464,13 @@ function expandRefUsage(seed, fields, alwaysJoinNames = []) {
                 ungroupings.push(...joinedUngroupings(refPath, def.ungroupings));
             }
         }
-        // For paths through joins, additionaly track join relationships
-        for (let joinLen = 1; joinLen < reference.path.length; joinLen++) {
+        // Track the joins along the path.  A path which ends at a join and carries
+        // a unique key requirement is an aggregate computed over that join's rows,
+        // which should then include the join's on-clause fields in the field usage.
+        // A path which merely names a join-typed value does not.
+        const endsInTraversedJoin = reference.uniqueKeyRequirement !== undefined;
+        const joinDepth = reference.path.length - (endsInTraversedJoin ? 0 : 1);
+        for (let joinLen = 1; joinLen <= joinDepth; joinLen++) {
             const joinPath = reference.path.slice(0, joinLen);
             const joinDef = inNamespace(joinPath, fieldNameSpace);
             if (!joinDef)

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

@@ -803,14 +803,8 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
         return this.visitTimezoneStatement(cx.timezoneStatement());
     }
     visitTimezoneStatement(cx) {
-        const timezone = this.getPlainStringFrom(cx);
-        const timezoneStatement = this.astAt(new ast.TimezoneStatement(timezone), cx.string());
-        if (!timezoneStatement.isValid) {
-            this.astError(timezoneStatement, 'invalid-timezone', {
-                timezone: timezoneStatement.tz,
-            });
-        }
-        return this.astAt(timezoneStatement, cx);
+        const timezone = this.astAt(new ast.ExprString(this.getPlainStringFrom(cx)), cx.string());
+        return this.astAt(new ast.TimezoneStatement(timezone), cx);
     }
     visitQueryProperties(pcx) {
         const qProps = this.only(pcx.queryStatement().map(qcx => this.astAt(this.visit(qcx), qcx)), x => ast.isQueryProperty(x) && x, 'query statement');

package/dist/lang/parse-log.d.ts

@@ -154,12 +154,10 @@ type MessageParameterTypes = {
     'top-by-non-aggregate': string;
     'definition-name-conflict': string;
     'invalid-field-in-index-query': string;
-    'invalid-wildcard-source': string;
-    'wildcard-source-not-found': string;
     'name-conflict-in-wildcard-expansion': string;
     'invalid-parameter-reference': string;
     'parameter-not-found': string;
-    'wildcard-source-not-defined': string;
+    'wildcard-matched-no-fields': string;
     'unexpected-index-segment': string;
     'accept-parameter': string;
     'except-parameter': string;

package/dist/lang/parse-malloy.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentLocation, DocumentPosition, DocumentReference, ImportLocation, ModelDef, SourceDef, SQLSourceDef, DependencyTree, DocumentRange } from '../model/malloy_types';
+import type { DocumentLocation, DocumentPosition, DocumentReference, ImportLocation, ModelDef, SourceDef, SQLSourceDef, DependencyTree, DocumentRange, VirtualMap } from '../model/malloy_types';
 import type { LogMessage, LogMessageOptions, MessageCode, MessageParameterType } from './parse-log';
 import { BaseMessageLogger } from './parse-log';
 import type { ZoneData } from './zone';
@@ -186,6 +186,7 @@ export declare class MalloyChildTranslator extends MalloyTranslation {
 export declare class MalloyTranslator extends MalloyTranslation {
     private readonly eventStream;
     readonly restrictedMode: boolean;
+    virtualMap?: VirtualMap | undefined;
     schemaZone: Zone<SourceDef>;
     importZone: Zone<string>;
     pretranslatedModels: Map<string, ModelDef>;
@@ -193,7 +194,7 @@ export declare class MalloyTranslator extends MalloyTranslation {
     connectionDialectZone: Zone<string>;
     logger: BaseMessageLogger;
     readonly root: MalloyTranslator;
-    constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null, eventStream?: EventStream | null, restrictedMode?: boolean);
+    constructor(rootURL: string, importURL?: string | null, preload?: ParseUpdate | null, eventStream?: EventStream | null, restrictedMode?: boolean, virtualMap?: VirtualMap | undefined);
     update(dd: ParseUpdate): void;
     private lockZonesIfRestricted;
     translate(extendingModel?: ModelDef): TranslateResponse;

package/dist/lang/parse-malloy.js

@@ -780,10 +780,11 @@ exports.MalloyChildTranslator = MalloyChildTranslator;
  * no need to call again, the translation is finished or error'd.
  */
 class MalloyTranslator extends MalloyTranslation {
-    constructor(rootURL, importURL = null, preload = null, eventStream = null, restrictedMode = false) {
+    constructor(rootURL, importURL = null, preload = null, eventStream = null, restrictedMode = false, virtualMap) {
         super(rootURL, importURL);
         this.eventStream = eventStream;
         this.restrictedMode = restrictedMode;
+        this.virtualMap = virtualMap;
         this.schemaZone = new zone_1.Zone();
         this.importZone = new zone_1.Zone();
         this.pretranslatedModels = new Map();

package/dist/lang/test/test-translator.d.ts

@@ -1,4 +1,4 @@
-import type { DocumentLocation, FieldDef, ModelDef, NamedModelObject, PipeSegment, Query, QueryFieldDef, StructDef, TurtleDef, SourceDef, TableSourceDef, SQLSourceDef, UserTypeDef } from '../../model/malloy_types';
+import type { DocumentLocation, FieldDef, ModelDef, NamedModelObject, PipeSegment, Query, QueryFieldDef, StructDef, TurtleDef, SourceDef, TableSourceDef, SQLSourceDef, UserTypeDef, VirtualMap } from '../../model/malloy_types';
 import { MalloyElement } from '../ast';
 import type { NameSpace } from '../ast/types/name-space';
 import type { ModelEntry } from '../ast/types/model-entry';
@@ -56,6 +56,7 @@ export interface TestTranslatorOptions {
     eventStream?: EventStream | null;
     internalModel?: ModelDef;
     restrictedMode?: boolean;
+    virtualMap?: VirtualMap;
     /**
      * Each entry is a compiler-flag tag fragment — the content that
      * would follow `##! ` in a Malloy source annotation. Rendered to