@malloydata/malloy 0.0.297 → 0.0.299

package/dist/api/core.d.ts

@@ -27,6 +27,7 @@ export interface CompileModelState {
     translator: MalloyTranslator;
     done: boolean;
     hasSource: boolean;
+    excludeReferences: boolean;
 }
 export declare function updateCompileModelState(state: CompileModelState, needs: Malloy.CompilerNeeds | undefined): void;
 export declare function newCompileModelState(request: Malloy.CompileModelRequest): CompileModelState;

package/dist/api/core.js

@@ -258,17 +258,18 @@ function updateCompileModelState(state, needs) {
     const update = compilerNeedsToUpdate(needs);
     performUpdate(state, update);
 }
-function _newCompileModelState(modelURL, compilerNeeds, extendURL) {
+function _newCompileModelState(modelURL, compilerNeeds, extendURL, excludeReferences = false) {
     var _a, _b, _c, _d;
     const translator = new lang_1.MalloyTranslator(modelURL, null, compilerNeedsToUpdate(compilerNeeds));
     const hasSource = ((_b = (_a = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.files) === null || _a === void 0 ? void 0 : _a.some(f => f.url === modelURL)) !== null && _b !== void 0 ? _b : false) ||
         ((_d = (_c = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.translations) === null || _c === void 0 ? void 0 : _c.some(t => t.url === modelURL)) !== null && _d !== void 0 ? _d : false);
     if (extendURL) {
         return {
-            extending: _newCompileModelState(extendURL, compilerNeeds),
+            extending: _newCompileModelState(extendURL, compilerNeeds, undefined, excludeReferences),
             translator,
             done: false,
             hasSource,
+            excludeReferences,
         };
     }
     else {
@@ -276,14 +277,15 @@ function _newCompileModelState(modelURL, compilerNeeds, extendURL) {
             translator,
             done: false,
             hasSource,
+            excludeReferences,
         };
     }
 }
 function newCompileModelState(request) {
-    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url);
+    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url, request.exclude_references);
 }
 function newCompileSourceState(request) {
-    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url);
+    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url, request.exclude_references);
 }
 // function hasNeeds(needs: Malloy.CompilerNeeds | undefined): boolean {
 //   if (needs === undefined) return false;
@@ -328,7 +330,7 @@ function _statedCompileModel(state) {
             const model = (0, to_stable_1.modelDefToModelInfo)(result.modelDef);
             return {
                 model,
-                modelDef: result.modelDef,
+                modelDef: maybeExcludeReferences(result.modelDef, state.excludeReferences),
                 timingInfo,
             };
         }
@@ -348,6 +350,14 @@ function _statedCompileModel(state) {
         return { compilerNeeds, logs: result.problems, timingInfo };
     }
 }
+function maybeExcludeReferences(modelDef, excludeReferences) {
+    if (!excludeReferences)
+        return modelDef;
+    return {
+        ...modelDef,
+        references: undefined,
+    };
+}
 function wrapResponse(response, defaultURL) {
     const logs = response.logs ? (0, util_1.mapLogs)(response.logs, defaultURL) : undefined;
     if (response.compilerNeeds) {
@@ -375,10 +385,6 @@ function wrapResponse(response, defaultURL) {
         };
     }
 }
-function _compileModel(modelURL, compilerNeeds, extendURL, state) {
-    state !== null && state !== void 0 ? state : (state = _newCompileModelState(modelURL, compilerNeeds, extendURL));
-    return _statedCompileModel(state);
-}
 function compileModel(request, state) {
     state !== null && state !== void 0 ? state : (state = newCompileModelState(request));
     return statedCompileModel(state);
@@ -435,7 +441,7 @@ function newCompileQueryState(request) {
         ...((_b = needs.files) !== null && _b !== void 0 ? _b : []),
     ];
     return {
-        ..._newCompileModelState(queryURL, needs, request.model_url),
+        ..._newCompileModelState(queryURL, needs, request.model_url, request.exclude_references),
         defaultRowLimit: request.default_row_limit,
     };
 }

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

@@ -49,17 +49,16 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
         }
     }
     getPipeSegment(refineIndex) {
+        var _a;
         if (refineIndex) {
             this.logError('refinement-of-index-segment', 'index query operations cannot be refined');
             return { type: 'index', indexFields: [] };
         }
         let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
         const indexFields = [];
-        const source = this.inputSpace().structDef();
         for (const [name, field] of this.entries()) {
             if (field instanceof space_field_1.SpaceField) {
                 let nextFieldUsage = undefined;
-                let logTo = undefined;
                 const wild = this.expandedWild[name];
                 if (wild) {
                     indexFields.push({ type: 'fieldref', path: wild.path, at: wild.at });
@@ -75,10 +74,9 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
                     else {
                         indexFields.push(fieldRef.refToField);
                         nextFieldUsage = check.found.typeDesc().fieldUsage;
-                        logTo = fieldRef;
                     }
                 }
-                fieldUsage = this.applyNextFieldUsage(source, fieldUsage, nextFieldUsage, logTo);
+                fieldUsage = (_a = (0, composite_source_utils_1.mergeFieldUsage)(fieldUsage, nextFieldUsage)) !== null && _a !== void 0 ? _a : [];
             }
         }
         this._fieldUsage = fieldUsage;

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

@@ -35,12 +35,10 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     compositeFieldUsers: ({
         type: 'filter';
         filter: model.FilterCondition;
-        logTo: MalloyElement;
     } | {
         type: 'field';
         name: string;
         field: SpaceField;
-        logTo: MalloyElement | undefined;
     })[];
     _fieldUsage: model.FieldUsage[] | undefined;
     get fieldUsage(): model.FieldUsage[];
@@ -52,11 +50,8 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     outputSpace(): QueryOperationSpace;
     protected addWild(wild: WildcardFieldReference): void;
     protected addValidatedCompositeFieldUserFromEntry(name: string, entry: SpaceEntry): void;
-    private getJoinOnFieldUsage;
-    protected getFieldUsageIncludingJoinOns(fieldUsage: model.FieldUsage[]): model.FieldUsage[];
-    addFieldUserFromFilter(filter: model.FilterCondition, logTo: MalloyElement): void;
+    addFieldUserFromFilter(filter: model.FilterCondition): void;
     newEntry(name: string, logTo: MalloyElement, entry: SpaceEntry): void;
-    protected applyNextFieldUsage(source: model.SourceDef, fieldUsage: model.FieldUsage[], nextFieldUsage: model.FieldUsage[] | undefined, _logTo: MalloyElement | undefined): model.FieldUsage[];
 }
 export declare abstract class QuerySpace extends QueryOperationSpace {
     addRefineFromFields(refineThis: model.PipeSegment): void;

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

@@ -66,7 +66,6 @@ const column_space_field_1 = require("./column-space-field");
 const static_space_1 = require("./static-space");
 const query_input_space_1 = require("./query-input-space");
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
-const struct_space_field_base_1 = require("./struct-space-field-base");
 /**
  * The output space of a query operation. It is not named "QueryOutputSpace"
  * because this is the namespace of the Query which is a layer of an output and
@@ -174,48 +173,20 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
                 type: 'field',
                 name,
                 field: entry,
-                logTo: undefined,
             });
         }
     }
-    getJoinOnFieldUsage(joinPath) {
-        var _a;
-        const reference = joinPath.map(n => new field_space_1.FieldName(n));
-        this.astEl.has({ reference });
-        const lookup = this.exprSpace.lookup(reference, 'private');
-        // Should always be found...
-        if (lookup.found && lookup.found instanceof struct_space_field_base_1.StructSpaceFieldBase) {
-            return (0, composite_source_utils_1.joinedFieldUsage)(joinPath.slice(0, -1), (_a = lookup.found.fieldDef().onFieldUsage) !== null && _a !== void 0 ? _a : (0, composite_source_utils_1.emptyFieldUsage)());
-        }
-        throw new Error('Unexpected join lookup was not found or not a struct');
-    }
-    getFieldUsageIncludingJoinOns(fieldUsage) {
-        let fieldUsageIncludingJoinOns = fieldUsage;
-        const joinPaths = (0, composite_source_utils_1.fieldUsageJoinPaths)(fieldUsage);
-        for (const joinPath of joinPaths) {
-            fieldUsageIncludingJoinOns = (0, composite_source_utils_1.mergeFieldUsage)(this.getJoinOnFieldUsage(joinPath), fieldUsageIncludingJoinOns);
-        }
-        return fieldUsageIncludingJoinOns;
-    }
-    addFieldUserFromFilter(filter, logTo) {
+    addFieldUserFromFilter(filter) {
         if (filter.fieldUsage !== undefined) {
-            this.compositeFieldUsers.push({ type: 'filter', filter, logTo });
+            this.compositeFieldUsers.push({ type: 'filter', filter });
         }
     }
     newEntry(name, logTo, entry) {
         if (entry instanceof space_field_1.SpaceField) {
-            this.compositeFieldUsers.push({ type: 'field', name, field: entry, logTo });
+            this.compositeFieldUsers.push({ type: 'field', name, field: entry });
         }
         super.newEntry(name, logTo, entry);
     }
-    applyNextFieldUsage(source, fieldUsage, nextFieldUsage, _logTo) {
-        var _a;
-        if (nextFieldUsage) {
-            const newFieldUsage = this.getFieldUsageIncludingJoinOns(nextFieldUsage);
-            fieldUsage = (_a = (0, composite_source_utils_1.mergeFieldUsage)(fieldUsage, newFieldUsage)) !== null && _a !== void 0 ? _a : [];
-        }
-        return fieldUsage;
-    }
 }
 exports.QueryOperationSpace = QueryOperationSpace;
 // Project and Reduce or "QuerySegments" are built from a QuerySpace
@@ -264,9 +235,9 @@ class QuerySpace extends QueryOperationSpace {
         return true;
     }
     queryFieldDefs() {
+        var _a;
         const fields = [];
         let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
-        const source = this.inputSpace().structDef();
         for (const user of this.compositeFieldUsers) {
             let nextFieldUsage = undefined;
             if (user.type === 'filter') {
@@ -306,7 +277,7 @@ class QuerySpace extends QueryOperationSpace {
                     // fields, but the individual fields didn't have field defs.
                 }
             }
-            fieldUsage = this.applyNextFieldUsage(source, fieldUsage, nextFieldUsage, user.logTo);
+            fieldUsage = (_a = (0, composite_source_utils_1.mergeFieldUsage)(fieldUsage, nextFieldUsage)) !== null && _a !== void 0 ? _a : [];
         }
         this._fieldUsage = fieldUsage;
         for (const drillDimension of this.drillDimensions) {

package/dist/lang/ast/field-space/struct-space-field-base.js

@@ -81,14 +81,14 @@ class StructSpaceFieldBase extends space_field_1.SpaceField {
                 type: this.structDef.type,
                 evalSpace: 'input',
                 expressionType: 'scalar',
-                fieldUsage: (_a = this.structDef.onFieldUsage) !== null && _a !== void 0 ? _a : [],
+                fieldUsage: (_a = this.structDef.fieldUsage) !== null && _a !== void 0 ? _a : [],
             };
         }
         return {
             ...TDU.atomicDef(this.structDef),
             evalSpace: 'input',
             expressionType: 'scalar',
-            fieldUsage: (_b = this.structDef.onFieldUsage) !== null && _b !== void 0 ? _b : [],
+            fieldUsage: (_b = this.structDef.fieldUsage) !== null && _b !== void 0 ? _b : [],
         };
     }
 }

package/dist/lang/ast/query-properties/filters.js

@@ -168,7 +168,7 @@ class Filter extends malloy_element_1.ListOf {
             const fExpr = this.checkedFilterCondition(filterFS, filter);
             if (fExpr !== undefined) {
                 executeFor.filters.push(fExpr);
-                executeFor.resultFS.addFieldUserFromFilter(fExpr, filter);
+                executeFor.resultFS.addFieldUserFromFilter(fExpr);
             }
         }
     }

package/dist/lang/ast/query-properties/qop-desc.js

@@ -31,6 +31,7 @@ const struct_utils_1 = require("../struct-utils");
 const static_space_1 = require("../field-space/static-space");
 const query_property_interface_1 = require("../types/query-property-interface");
 const partial_builder_1 = require("../query-builders/partial-builder");
+const utils_1 = require("../../utils");
 class QOpDesc extends malloy_element_1.ListOf {
     constructor() {
         super(...arguments);
@@ -55,7 +56,7 @@ class QOpDesc extends malloy_element_1.ListOf {
             if (el.forceQueryClass) {
                 if (guessType) {
                     if (guessType !== el.forceQueryClass) {
-                        el.logError(`illegal-${guessType}-operation`, `Not legal in ${guessType} query`);
+                        el.logError(`illegal-${guessType}-operation`, `Use of ${(0, utils_1.modernizeTermsForUserText)(el.forceQueryClass)} is not allowed in a ${(0, utils_1.modernizeTermsForUserText)(guessType)} query`);
                     }
                 }
                 else {

package/dist/lang/ast/source-properties/join.js

@@ -99,7 +99,7 @@ class KeyJoin extends Join {
                             right: exprX.value,
                         },
                     };
-                    inStruct.onFieldUsage = exprX.fieldUsage;
+                    inStruct.fieldUsage = exprX.fieldUsage;
                     return;
                 }
                 else {
@@ -142,7 +142,7 @@ class ExpressionJoin extends Join {
             return;
         }
         inStruct.onExpression = exprX.value;
-        inStruct.onFieldUsage = exprX.fieldUsage;
+        inStruct.fieldUsage = exprX.fieldUsage;
     }
     getStructDef(parameterSpace) {
         var _a;

package/dist/lang/syntax-errors/custom-error-messages.js

@@ -63,12 +63,17 @@ const checkCustomErrorMessage = (parser, offendingSymbol, errorCases) => {
                 }
             }
             const errReplace = (s) => {
-                const rs = s
+                let rs = s
                     .replace('${currentToken}', currentToken.text || '')
                     .replace('${offendingSymbol}', (offendingSymbol === null || offendingSymbol === void 0 ? void 0 : offendingSymbol.text) || '');
                 try {
                     const previousToken = parser.inputStream.LT(-1);
-                    return rs.replace('${previousToken}', previousToken.text || '');
+                    rs = rs.replace('${previousToken}', previousToken.text || '');
+                    const offendingSymbolIndex = offendingSymbol === null || offendingSymbol === void 0 ? void 0 : offendingSymbol.tokenIndex;
+                    if (offendingSymbolIndex && offendingSymbolIndex > 0) {
+                        const previousSymbol = parser.inputStream.get(offendingSymbolIndex - 1);
+                        rs = rs.replace('${previousSymbol}', previousSymbol.text || '');
+                    }
                 }
                 catch (ex) {
                     // This shouldn't ever occur, but if it does, just leave the untokenized message.

package/dist/lang/syntax-errors/malloy-parser-error-listener.js

@@ -170,6 +170,51 @@ exports.malloyCustomErrorCases = [
             with: ['run:', 'query:', 'source:'],
         },
     },
+    {
+        errorMessage: '`count(distinct expression)` deprecated, use `count(expression)` instead.',
+        offendingSymbol: MalloyParser_1.MalloyParser.DISTINCT,
+        ruleContextOptions: ['fieldExpr'],
+        precedingTokenOptions: [[MalloyParser_1.MalloyParser.COUNT], [MalloyParser_1.MalloyParser.OPAREN]],
+    },
+    {
+        errorMessage: "Unexpected type '${offendingSymbol}' in dimension definition. Expected an expression or field reference.",
+        offendingSymbolTextOptions: [
+            'string',
+            'number',
+            'int',
+            'integer',
+            'bool',
+            'boolean',
+            'date',
+            'time',
+            'timestamp',
+            'array',
+        ],
+        ruleContextOptions: ['fieldExpr'],
+        precedingTokenOptions: [[MalloyParser_1.MalloyParser.IDENTIFIER], [MalloyParser_1.MalloyParser.IS]],
+    },
+    // Identify a case where a user is using an open parenthesis following an
+    // identifier that does not represent a valid function.
+    {
+        errorMessage: "Unknown function '${previousSymbol}'. You can find available functions here: https://docs.malloydata.dev/documentation/language/functions",
+        offendingSymbol: MalloyParser_1.MalloyParser.OPAREN,
+        ruleContextOptions: ['vExpr'],
+        precedingTokenOptions: [[MalloyParser_1.MalloyParser.IDENTIFIER]],
+    },
+    {
+        errorMessage: "The 'project:' keyword is no longer supported. Use 'select:' instead.",
+        offendingSymbol: MalloyParser_1.MalloyParser.PROJECT,
+    },
+    {
+        errorMessage: "Unsupported keyword 'as'. Use 'is' to name something (ex: `dimension: name is expression`)",
+        offendingSymbolTextOptions: ['as'],
+        ruleContextOptions: ['isDefine'],
+    },
+    {
+        // Broader catch-all case for the 'as' keyword, including an alternative example.
+        errorMessage: "Unsupported keyword 'as'. Use 'is' to name something (ex: `select: new_name is column_name`)",
+        offendingSymbolTextOptions: ['as'],
+    },
 ];
 class MalloyParserErrorListener {
     constructor(

package/dist/lang/utils.d.ts

@@ -19,6 +19,13 @@ export declare function rangeFromContext(sourceInfo: SourceInfo | undefined, pcx
  * to the line/char positions favored by LSP and VSCode.
  */
 export declare function getSourceInfo(code: string): SourceInfo;
+/**
+ * Rewrites text that is going to be presented to end users to avoid
+ * using terminology that is deprecated or changed.
+ *
+ * @param text raw text that is being used internally in Malloy
+ */
+export declare function modernizeTermsForUserText(text: string): string;
 export interface ParseInfo {
     root: ParseTree;
     tokenStream: CommonTokenStream;

package/dist/lang/utils.js

@@ -28,6 +28,7 @@ exports.rangeFromTokens = rangeFromTokens;
 exports.rangeFromToken = rangeFromToken;
 exports.rangeFromContext = rangeFromContext;
 exports.getSourceInfo = getSourceInfo;
+exports.modernizeTermsForUserText = modernizeTermsForUserText;
 function locationContainsPosition(location, position) {
     return (location.range.start.line <= position.line &&
         location.range.end.line >= position.line &&
@@ -112,4 +113,16 @@ function getSourceInfo(code) {
     }
     return info;
 }
+/**
+ * Rewrites text that is going to be presented to end users to avoid
+ * using terminology that is deprecated or changed.
+ *
+ * @param text raw text that is being used internally in Malloy
+ */
+function modernizeTermsForUserText(text) {
+    if (text === 'project') {
+        return 'select';
+    }
+    return text;
+}
 //# sourceMappingURL=utils.js.map

package/dist/model/composite_source_utils.js

@@ -26,12 +26,11 @@ exports.logCompositeError = logCompositeError;
 exports.compileFilterExpression = compileFilterExpression;
 const malloy_filter_1 = require("@malloydata/malloy-filter");
 const malloy_types_1 = require("./malloy_types");
-const utils_1 = require("./utils");
-const utils_2 = require("../lang/utils");
+const utils_1 = require("../lang/utils");
 function _resolveCompositeSources(path, source, rootFields, nests, fieldUsage, 
 // for resolving nested composites; the list of sources to try
 sources) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     // TODO skip all this if the tree doesn't have any composite sources
     let base = { ...source };
     let anyComposites = false;
@@ -62,8 +61,9 @@ sources) {
                     fieldNames.add((_a = field.as) !== null && _a !== void 0 ? _a : field.name);
                 }
             }
+            const fieldUsageWithWheres = (_b = mergeFieldUsage(fieldUsage, getFieldUsageFromFilterList(inputSource))) !== null && _b !== void 0 ? _b : [];
             const fieldsForLookup = [...nonCompositeFields, ...inputSource.fields];
-            const expanded = expandFieldUsage(fieldUsage, fieldsForLookup);
+            const expanded = expandFieldUsage(fieldUsageWithWheres, fieldsForLookup);
             if (expanded.missingFields.length > 0) {
                 // A lookup failed while expanding, which means this source certainly won't work
                 for (const missingField of expanded.missingFields) {
@@ -96,8 +96,13 @@ sources) {
             if (inputSource.type === 'composite') {
                 const resolveInner = _resolveCompositeSources(path, inputSource, genRootFields(rootFields, path, fieldsForLookup, false), nests, compositeUsageInThisSource, inputSource.sources);
                 if ('error' in resolveInner) {
-                    // Third point where we abort; if a nested composite failed
-                    abort();
+                    // Third point where we abort; if a nested composite failed; we don't call abort() because we want to unnest the failures from
+                    if (resolveInner.error.code === 'no_suitable_composite_source_input') {
+                        failures.push(...resolveInner.error.data.failures);
+                    }
+                    else {
+                        abort();
+                    }
                     continue overSources;
                 }
                 base = {
@@ -116,7 +121,7 @@ sources) {
                 ...base,
                 fields,
                 arguments: source.arguments,
-                filterList: [...((_b = source.filterList) !== null && _b !== void 0 ? _b : []), ...((_c = base.filterList) !== null && _c !== void 0 ? _c : [])],
+                filterList: [...((_c = source.filterList) !== null && _c !== void 0 ? _c : []), ...((_d = base.filterList) !== null && _d !== void 0 ? _d : [])],
             };
             const joinError = processJoins(path, base, rootFields, nests, expandedCategorized);
             // Fourth point where we abort: if a join failed
@@ -198,6 +203,7 @@ function onlyCompositeUsage(fieldUsage, fields) {
     });
 }
 function expandFieldUsage(fieldUsage, fields) {
+    var _a;
     const allFieldPathsReferenced = [...fieldUsage];
     const joinPathsProcessed = [];
     const missingFields = [];
@@ -217,17 +223,15 @@ function expandFieldUsage(fieldUsage, fields) {
             continue;
         }
         if ((0, malloy_types_1.isAtomic)(def)) {
-            const fieldUsage = getFieldUsageForField(def);
+            const fieldUsage = (_a = def.fieldUsage) !== null && _a !== void 0 ? _a : [];
             allFieldPathsReferenced.push(...fieldUsageAt(joinedFieldUsage(referenceJoinPath, fieldUsage), reference.at).filter(u1 => !allFieldPathsReferenced.some(u2 => pathEq(u1.path, u2.path))));
         }
         if (reference.path.length > 1) {
             if (!joinPathsProcessed.some(p => pathEq(p, referenceJoinPath))) {
                 joinPathsProcessed.push(referenceJoinPath);
                 const join = lookup(referenceJoinPath, fields);
-                // Don't want to actually include the name of the join; just the path to the join
-                const joinJoinPath = referenceJoinPath.slice(0, -1);
-                const fieldUsage = getFieldUsageForField(join);
-                allFieldPathsReferenced.push(...fieldUsageAt(joinedFieldUsage(joinJoinPath, fieldUsage), reference.at).filter(u1 => !allFieldPathsReferenced.some(u2 => pathEq(u1.path, u2.path))));
+                const joinFieldUsage = getJoinFieldUsage(join, referenceJoinPath);
+                allFieldPathsReferenced.push(...fieldUsageAt(joinFieldUsage, reference.at).filter(u1 => !allFieldPathsReferenced.some(u2 => pathEq(u1.path, u2.path))));
             }
         }
     }
@@ -384,14 +388,19 @@ function processJoins(path, base, rootFields, nests, categorizedFieldUsage) {
     }
     return { anyComposites, errors };
 }
-function resolveCompositeSources(source, segment, fieldUsage) {
+function getFieldUsageFromFilterList(source) {
     var _a;
+    return ((_a = source.filterList) !== null && _a !== void 0 ? _a : []).flatMap(filter => { var _a; return (_a = filter.fieldUsage) !== null && _a !== void 0 ? _a : []; });
+}
+function resolveCompositeSources(source, segment, fieldUsage) {
+    var _a, _b;
     const sourceExtensions = (0, malloy_types_1.isQuerySegment)(segment)
         ? (_a = segment.extendSource) !== null && _a !== void 0 ? _a : []
         : [];
     const nestLevels = extractNestLevels(segment);
     const fields = mergeFields(source.fields, sourceExtensions);
-    const result = _resolveCompositeSources([], source, fields, nestLevels, fieldUsage);
+    const fieldUsageWithWheres = (_b = mergeFieldUsage(fieldUsage, getFieldUsageFromFilterList(source))) !== null && _b !== void 0 ? _b : [];
+    const result = _resolveCompositeSources([], source, fields, nestLevels, fieldUsageWithWheres);
     if ('success' in result) {
         if (result.anyComposites) {
             return { sourceDef: result.success, error: undefined };
@@ -498,27 +507,6 @@ function isCompositeField(fieldDef) {
 function getNonCompositeFields(source) {
     return source.fields.filter(f => !isCompositeField(f));
 }
-function getFieldUsageFromExpr(expr) {
-    const fieldUsage = [];
-    for (const node of (0, utils_1.exprWalk)(expr)) {
-        if (node.node === 'field') {
-            fieldUsage.push({
-                path: node.path,
-                at: node.at,
-            });
-        }
-    }
-    return fieldUsage;
-}
-function getFieldUsageForField(field) {
-    if ((0, malloy_types_1.isAtomic)(field) && field.e) {
-        return getFieldUsageFromExpr(field.e);
-    }
-    else if ((0, malloy_types_1.isJoined)(field) && field.onExpression) {
-        return getFieldUsageFromExpr(field.onExpression);
-    }
-    return [];
-}
 function nestLevelsAt(nests, at) {
     var _a;
     if (at === undefined)
@@ -570,7 +558,7 @@ function joinedUngroupings(joinPath, ungroupings) {
     }));
 }
 function extractNestLevels(segment) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const fieldsReferencedDirectly = [];
     const fieldsReferenced = [];
     const nested = [];
@@ -594,12 +582,13 @@ function extractNestLevels(segment) {
                 nested.push(nestLevelsAt(extractNestLevels(head), head.referencedAt));
             }
             else {
-                fieldsReferenced.push(...getFieldUsageForField(field));
-                ungroupings.push(...((_a = field.ungroupings) !== null && _a !== void 0 ? _a : []));
-                requiredGroupBys.push(...((_b = field.requiresGroupBy) !== null && _b !== void 0 ? _b : []));
+                const fieldUsage = (_a = field.fieldUsage) !== null && _a !== void 0 ? _a : [];
+                fieldsReferenced.push(...fieldUsage);
+                ungroupings.push(...((_b = field.ungroupings) !== null && _b !== void 0 ? _b : []));
+                requiredGroupBys.push(...((_c = field.requiresGroupBy) !== null && _c !== void 0 ? _c : []));
             }
         }
-        for (const filter of (_c = segment.filterList) !== null && _c !== void 0 ? _c : []) {
+        for (const filter of (_d = segment.filterList) !== null && _d !== void 0 ? _d : []) {
             if (!(0, malloy_types_1.expressionIsScalar)(filter.expressionType))
                 continue;
             const fields = getSingleValueFilterFields(filter.e);
@@ -677,7 +666,7 @@ function isSingleValueFilterNode(e) {
     }
 }
 function expandRefs(nests, fields) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d;
     const newNests = [];
     const requiredGroupBys = [...nests.requiredGroupBys];
     const allUngroupings = [...nests.ungroupings];
@@ -718,7 +707,7 @@ function expandRefs(nests, fields) {
             if (def.ungroupings) {
                 allUngroupings.push(...joinedUngroupings(joinPath, ungroupingsAt(def.ungroupings, field.at)));
             }
-            const fieldUsage = getFieldUsageForField(def);
+            const fieldUsage = (_a = def.fieldUsage) !== null && _a !== void 0 ? _a : [];
             const moreReferences = fieldUsageAt(joinedFieldUsage(joinPath, fieldUsage), field.at).filter(u1 => !references.some(u2 => pathEq(u1.path, u2.path)));
             references.push(...moreReferences);
         }
@@ -726,10 +715,8 @@ function expandRefs(nests, fields) {
             if (!joinPathsProcessed.some(p => pathEq(p, joinPath))) {
                 joinPathsProcessed.push(joinPath);
                 const join = lookup(joinPath, fields);
-                // Don't want to actually include the name of the join; just the path to the join
-                const joinJoinPath = joinPath.slice(0, -1);
-                const fieldUsage = getFieldUsageForField(join);
-                references.push(...fieldUsageAt(joinedFieldUsage(joinJoinPath, fieldUsage), field.at).filter(u1 => !references.some(u2 => pathEq(u1.path, u2.path))));
+                const joinFieldUsage = getJoinFieldUsage(join, joinPath);
+                references.push(...fieldUsageAt(joinFieldUsage, field.at).filter(u1 => !references.some(u2 => pathEq(u1.path, u2.path))));
             }
         }
     }
@@ -740,10 +727,10 @@ function expandRefs(nests, fields) {
             fieldsReferencedDirectly: [],
             ungroupings: [],
             nested: [],
-            requiredGroupBys: (_a = ungrouping.requiresGroupBy) !== null && _a !== void 0 ? _a : [],
+            requiredGroupBys: (_b = ungrouping.requiresGroupBy) !== null && _b !== void 0 ? _b : [],
             singleValueFilters: [],
         }, fields);
-        missingFields.push(...((_b = expanded.missingFields) !== null && _b !== void 0 ? _b : []));
+        missingFields.push(...((_c = expanded.missingFields) !== null && _c !== void 0 ? _c : []));
         for (const field of expanded.result.requiredGroupBys) {
             if (isUngroupedBy(ungrouping, field.path)) {
                 unsatisfiableGroupBys.push(field);
@@ -753,7 +740,7 @@ function expandRefs(nests, fields) {
     const nested = [];
     for (const level of [...nests.nested, ...newNests]) {
         const expanded = expandRefs(level, fields);
-        missingFields.push(...((_c = expanded.missingFields) !== null && _c !== void 0 ? _c : []));
+        missingFields.push(...((_d = expanded.missingFields) !== null && _d !== void 0 ? _d : []));
         nested.push(expanded.result);
         unsatisfiableGroupBys.push(...expanded.result.unsatisfiableGroupBys);
     }
@@ -768,6 +755,15 @@ function expandRefs(nests, fields) {
         missingFields: missingFields.length > 0 ? missingFields : undefined,
     };
 }
+function getJoinFieldUsage(join, joinPath) {
+    var _a, _b;
+    return ((_b = mergeFieldUsage(
+    // For `fieldUsage` from join `on`, we need the path excluding the join name, since it's
+    // already rooted at the parent
+    joinedFieldUsage(joinPath.slice(0, -1), (_a = join.fieldUsage) !== null && _a !== void 0 ? _a : []), 
+    // For `fieldUsage` from join `where`s, we need the path including the join name
+    joinedFieldUsage(joinPath, (0, malloy_types_1.isSourceDef)(join) ? getFieldUsageFromFilterList(join) : []))) !== null && _b !== void 0 ? _b : []);
+}
 function isUngroupedBy(ungrouping, groupedBy) {
     if (ungrouping.ungroupedFields === '*')
         return true;
@@ -882,13 +878,14 @@ function logCompositeError(error, logTo) {
     if (error.code === 'no_suitable_composite_source_input') {
         const firstFails = error.data.failures.map(failure => failure.issues[0]);
         const sorted = sortIssuesByReferenceLocation(firstFails);
+        const joinPath = error.data.path;
         const usages = sorted.map(issueFieldUsage);
         const lastIssue = sorted[sorted.length - 1];
         const lastUsage = usages[usages.length - 1];
         const conflictingUsage = firstFails
             .filter(i => i.type === 'missing-field')
             .map(i => i.field);
-        const fConflictingUsage = formatFieldUsages(conflictingUsage);
+        const fConflictingUsage = formatFieldUsages(joinedFieldUsage(joinPath, conflictingUsage));
         const dConflictingUsage = conflictingUsage.length > 0
             ? `there is no composite input source which defines all of ${fConflictingUsage}`
             : undefined;
@@ -912,12 +909,12 @@ function logCompositeError(error, logTo) {
             ? `${joinPlural} ${formatPaths(uniqueFailedJoins)} could not be resolved`
             : undefined;
         const dLastIssue = lastUsage
-            ? `uses field ${formatFieldUsages([lastUsage])}, resulting in`
+            ? `uses field ${formatFieldUsages(joinedFieldUsage(joinPath, [lastUsage]))}, resulting in`
             : 'results in';
         const dIssues = dConflictingUsageAndMissingGroupBys
-            ? commaAndList([dConflictingUsageAndMissingGroupBys, dFailedJoins].filter(utils_2.isNotUndefined))
-            : commaAndList([dConflictingUsage, dMissingGroupBys, dFailedJoins].filter(utils_2.isNotUndefined));
-        const message = `This operation ${dLastIssue} invalid usage of the composite source, as ${dIssues} (fields required in source: ${formatFieldUsages(error.data.usage)})`;
+            ? commaAndList([dConflictingUsageAndMissingGroupBys, dFailedJoins].filter(utils_1.isNotUndefined))
+            : commaAndList([dConflictingUsage, dMissingGroupBys, dFailedJoins].filter(utils_1.isNotUndefined));
+        const message = `This operation ${dLastIssue} invalid usage of the composite source, as ${dIssues} (fields required in source: ${formatFieldUsages(joinedFieldUsage(joinPath, error.data.usage))})`;
         logTo.logError('could-not-resolve-composite-source', message, {
             at: issueLocation(lastIssue),
         });

package/dist/model/malloy_types.d.ts

@@ -467,7 +467,7 @@ export interface JoinBase {
     join: JoinType;
     matrixOperation?: MatrixOperation;
     onExpression?: Expr;
-    onFieldUsage?: FieldUsage[];
+    fieldUsage?: FieldUsage[];
     accessModifier?: NonDefaultAccessModifierLabel | undefined;
 }
 export type Joinable = CompositeSourceDef | TableSourceDef | SQLSourceDef | QuerySourceDef | RepeatedRecordDef | RecordDef | ArrayDef;

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.297";
+export declare const MALLOY_VERSION = "0.0.299";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.297",
+  "version": "0.0.299",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,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.297",
-    "@malloydata/malloy-interfaces": "0.0.297",
-    "@malloydata/malloy-tag": "0.0.297",
+    "@malloydata/malloy-filter": "0.0.299",
+    "@malloydata/malloy-interfaces": "0.0.299",
+    "@malloydata/malloy-tag": "0.0.299",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",