@malloydata/malloy 0.0.288 → 0.0.290

package/dist/index.d.ts

@@ -5,7 +5,7 @@ export { isSourceDef, Segment, isBasicAtomic, isJoined, isJoinedSource, isSampli
 export { malloyToQuery, MalloyTranslator, } from './lang';
 export type { LogMessage, TranslateResponse } from './lang';
 export { Model, Malloy, Runtime, AtomicFieldType, ConnectionRuntime, SingleConnectionRuntime, EmptyURLReader, InMemoryURLReader, FixedConnectionMap, MalloyError, JoinRelationship, SourceRelationship, DateTimeframe, TimestampTimeframe, PreparedResult, Result, QueryMaterializer, CSVWriter, JSONWriter, Parse, DataWriter, Explore, InMemoryModelCache, CacheManager, } from './malloy';
-export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, ModelCache, CachedModel, DateField, TimestampField, } from './malloy';
+export type { PreparedQuery, Field, AtomicField, ExploreField, QueryField, SortableField, DataArray, DataRecord, DataColumn, DataArrayOrRecord, Loggable, ModelMaterializer, DocumentTablePath, DocumentSymbol, ResultJSON, PreparedResultJSON, PreparedResultMaterializer, ExploreMaterializer, WriteStream, SerializedExplore, ModelCache, CachedModel, DateField, TimestampField, SourceComponentInfo, } from './malloy';
 export type { QueryOptionsReader, RunSQLOptions } from './run_sql_options';
 export type { EventStream, ModelString, ModelURL, QueryString, QueryURL, URLReader, InvalidationKey, } from './runtime_types';
 export type { Connection, ConnectionConfig, ConnectionFactory, ConnectionParameter, ConnectionParameterValue, ConnectionConfigSchema, FetchSchemaOptions, InfoConnection, LookupConnection, PersistSQLResults, PooledConnection, TestableConnection, StreamingConnection, } from './connection/types';

package/dist/lang/ast/expressions/time-literal.js

@@ -162,6 +162,7 @@ class LiteralTimestamp extends TimeLiteral {
         const hasSubsecs = literalTs.match(/^([^.,]+)[,.](\d+)$/);
         if (hasSubsecs) {
             literalTs = hasSubsecs[1];
+            units = undefined;
             // subSecs = hasSubsecs[2];
             // mtoy TODO subsecond units not ignored
         }
@@ -199,6 +200,28 @@ class GranularLiteral extends TimeLiteral {
         let rangeEnd = this.getNext();
         if (rangeEnd) {
             const testValue = left.getExpression(fs);
+            if (testValue.type === 'date' && op === '=' && this.units === 'day') {
+                // TODO remove the === 'day' check above and warn
+                // if (this.units !== 'day') {
+                //   this.logWarning(
+                //     'time-equality-not-granular',
+                //     `Equality comparisons of a date to a literal ${this.units} will compare the first day of the ${this.units}; use a literal day instead, or use \`?\` to check whether the date is within the ${this.units}.`
+                //   );
+                // }
+                return super.apply(fs, op, left);
+            }
+            if (testValue.type === 'timestamp' &&
+                op === '=' &&
+                this.units === undefined) {
+                // TODO remove the === 'second' check above and warn
+                // if (this.units !== 'second') {
+                //   this.logWarning(
+                //     'time-equality-not-granular',
+                //     `Equality comparisons of a timestamp to a literal ${this.units} will compare the first instant of the ${this.units}; use a literal timestamp (to the second) instead, or use \`?\` to check whether the date is within the ${this.units}.`
+                //   );
+                // }
+                return super.apply(fs, op, left);
+            }
             if (testValue.type === 'timestamp') {
                 const newStart = (0, expression_def_1.getMorphicValue)(rangeStart, 'timestamp');
                 const newEnd = (0, expression_def_1.getMorphicValue)(rangeEnd, 'timestamp');

package/dist/lang/ast/query-elements/query-arrow.js

@@ -81,7 +81,7 @@ class QueryArrow extends query_base_1.QueryBase {
         if (segment !== undefined) {
             const unsatisfiedGroupBys = (0, composite_source_utils_1.checkRequiredGroupBys)(compositeResolvedSourceDef !== null && compositeResolvedSourceDef !== void 0 ? compositeResolvedSourceDef : inputStruct, segment);
             for (const unsatisfiedGroupBy of unsatisfiedGroupBys) {
-                this.logError('missing-required-group-by', `Group by of \`${unsatisfiedGroupBy.path.join('.')}\` is required but not present`, {
+                this.logError('missing-required-group-by', `Group by or single value filter of \`${unsatisfiedGroupBy.path.join('.')}\` is required but not present`, {
                     at: unsatisfiedGroupBy.at,
                 });
             }

package/dist/lang/ast/query-utils.d.ts

@@ -2,4 +2,3 @@ import type { PipeSegment } from '../../model';
 import type { MalloyElement } from './types/malloy-element';
 export declare function detectAndRemovePartialStages(pipeline: PipeSegment[], logTo: MalloyElement): PipeSegment[];
 export declare function unsatisfiedRequiredGroupBys(segment: PipeSegment | undefined, requiredGroupBys: string[][]): string[][];
-export declare function validateRequiredGroupBys(segment: PipeSegment, logTo: MalloyElement, requiredGroupBys: string[][]): void;

package/dist/lang/ast/query-utils.js

@@ -24,7 +24,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectAndRemovePartialStages = detectAndRemovePartialStages;
 exports.unsatisfiedRequiredGroupBys = unsatisfiedRequiredGroupBys;
-exports.validateRequiredGroupBys = validateRequiredGroupBys;
 const model_1 = require("../../model");
 // We don't want to ever generate actual 'partial' stages, so convert this
 // into a reduce so the compiler doesn't explode
@@ -67,10 +66,4 @@ function unsatisfiedRequiredGroupBys(segment, requiredGroupBys) {
     }
     return result;
 }
-function validateRequiredGroupBys(segment, logTo, requiredGroupBys) {
-    const missing = unsatisfiedRequiredGroupBys(segment, requiredGroupBys);
-    for (const requiredGroupBy of missing) {
-        logTo.logError('missing-required-group-by', `Group by of \`${requiredGroupBy.join('.')}\` is required but not present`);
-    }
-}
 //# sourceMappingURL=query-utils.js.map

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

@@ -116,7 +116,7 @@ class NamedSource extends source_1.Source {
         return this.evaluateArguments(parameterSpace, base.parameters, []);
     }
     evaluateArguments(parameterSpace, parametersIn, parametersOut) {
-        var _a, _b;
+        var _a, _b, _c;
         const outArguments = { ...this.sourceArguments };
         const passedNames = new Set();
         for (const argument of (_a = this.args) !== null && _a !== void 0 ? _a : []) {
@@ -144,7 +144,15 @@ class NamedSource extends source_1.Source {
                 if (pVal.type === 'filter expression' &&
                     parameter.type === 'filter expression' &&
                     parameter.filterType) {
-                    (0, expression_def_1.checkFilterExpression)(argument.value, parameter.filterType, value);
+                    if (value.node === 'parameter') {
+                        const filterType = (_c = pVal['filterType']) !== null && _c !== void 0 ? _c : 'missing-filter-type';
+                        if (parameter.filterType !== filterType) {
+                            argument.value.logError('filter-expression-type', `Parameter types filter<${parameter.filterType}> and filter<${filterType}> do not match`);
+                        }
+                    }
+                    else {
+                        (0, expression_def_1.checkFilterExpression)(argument.value, parameter.filterType, value);
+                    }
                 }
                 if (pVal.type !== parameter.type && (0, malloy_types_1.isCastType)(parameter.type)) {
                     value = (0, time_utils_1.castTo)(parameter.type, pVal.value, pVal.type, true);

package/dist/lang/ast/typedesc-utils.d.ts

@@ -1,4 +1,4 @@
-import type { AtomicTypeDef, TypeDesc } from '../../model';
+import type { AtomicTypeDef, EvalSpace, Parameter, TypeDesc } from '../../model';
 export declare const nullT: TypeDesc;
 export declare const numberT: TypeDesc;
 export declare const stringT: TypeDesc;
@@ -46,3 +46,4 @@ export declare function inspect(...types: (TypeDesc | undefined)[]): string;
  * create a field, don't copy the non type fields.
  */
 export declare function atomicDef(td: AtomicTypeDef | TypeDesc): AtomicTypeDef;
+export declare function parameterTypeDesc(p: Parameter, evalSpace: EvalSpace): TypeDesc;

package/dist/lang/ast/typedesc-utils.js

@@ -29,6 +29,7 @@ exports.typeIn = typeIn;
 exports.typeEq = typeEq;
 exports.inspect = inspect;
 exports.atomicDef = atomicDef;
+exports.parameterTypeDesc = parameterTypeDesc;
 const model_1 = require("../../model");
 function mkTypeDesc(
 // The problem is that record and array, as currently defined, require a dialect
@@ -155,4 +156,16 @@ function atomicDef(td) {
     }
     return { type: 'error' };
 }
+function parameterTypeDesc(p, evalSpace) {
+    const t = p.type;
+    const theType = t === 'filter expression'
+        ? { type: t, filterType: p.filterType }
+        : atomicDef(p);
+    return {
+        ...theType,
+        expressionType: 'scalar',
+        evalSpace,
+        fieldUsage: [],
+    };
+}
 //# sourceMappingURL=typedesc-utils.js.map

package/dist/lang/ast/types/space-param.js

@@ -78,15 +78,7 @@ class AbstractParameter extends SpaceParam {
         return this._parameter;
     }
     typeDesc() {
-        const p = this.parameter();
-        const t = p.type;
-        const theType = t === 'filter expression' ? { type: t } : TDU.atomicDef(p);
-        return {
-            ...theType,
-            expressionType: 'scalar',
-            evalSpace: 'constant',
-            fieldUsage: [],
-        };
+        return TDU.parameterTypeDesc(this.parameter(), 'constant');
     }
 }
 exports.AbstractParameter = AbstractParameter;
@@ -99,17 +91,9 @@ class DefinedParameter extends SpaceParam {
         return this.paramDef;
     }
     typeDesc() {
-        const p = this.parameter();
-        const t = p.type;
-        const theType = t === 'filter expression' ? { type: t } : TDU.atomicDef(p);
-        return {
-            ...theType,
-            expressionType: 'scalar',
-            // TODO Not sure whether params are considered "input space". It seems like they
-            // could be input or constant, depending on usage (same as above).
-            evalSpace: 'input',
-            fieldUsage: [],
-        };
+        // TODO Not sure whether params are considered "input space". It seems like they
+        // could be input or constant, depending on usage (same as above).
+        return TDU.parameterTypeDesc(this.parameter(), 'input');
     }
 }
 exports.DefinedParameter = DefinedParameter;

package/dist/malloy.d.ts

@@ -2,7 +2,7 @@ import type { RunSQLOptions } from './run_sql_options';
 import type { DocumentCompletion as DocumentCompletionDefinition, DocumentSymbol as DocumentSymbolDefinition, LogMessage } from './lang';
 import { MalloyTranslator } from './lang';
 import type { DocumentHelpContext } from './lang/parse-tree-walkers/document-help-context-walker';
-import type { CompiledQuery, DocumentLocation, DocumentReference, BooleanFieldDef, JSONFieldDef, NumberFieldDef, StringFieldDef, FilterCondition, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQuery, QueryData, QueryDataRow, QueryResult, SearchIndexResult, SearchValueMapResult, StructDef, TurtleDef, NativeUnsupportedFieldDef, QueryRunStats, ImportLocation, Annotation, SQLSourceDef, AtomicFieldDef, DateFieldDef, TimestampFieldDef, SourceDef, QueryToMaterialize, Argument } from './model';
+import type { CompiledQuery, DocumentLocation, DocumentReference, BooleanFieldDef, JSONFieldDef, NumberFieldDef, StringFieldDef, FilterCondition, Query as InternalQuery, ModelDef, DocumentPosition as ModelDocumentPosition, NamedQuery, QueryData, QueryDataRow, QueryResult, SearchIndexResult, SearchValueMapResult, StructDef, TurtleDef, NativeUnsupportedFieldDef, QueryRunStats, ImportLocation, Annotation, SQLSourceDef, AtomicFieldDef, DateFieldDef, TimestampFieldDef, SourceDef, QueryToMaterialize, Argument, TableSourceDef } from './model';
 import type { EventStream, InvalidationKey, ModelString, ModelURL, QueryString, QueryURL, URLReader } from './runtime_types';
 import type { Connection, FetchSchemaOptions, InfoConnection, LookupConnection } from './connection/types';
 import type { Tag } from '@malloydata/malloy-tag';
@@ -19,6 +19,15 @@ export interface Loggable {
     warn: (message?: any, ...optionalParams: any[]) => void;
     error: (message?: any, ...optionalParams: any[]) => void;
 }
+export type SourceComponentInfo = {
+    type: 'table';
+    tableName: string;
+    sourceID: string;
+} | {
+    type: 'sql';
+    selectStatement: string;
+    sourceID: string;
+};
 export interface ParseOptions {
     importBaseURL?: URL;
     testEnvironment?: boolean;
@@ -98,7 +107,7 @@ export declare class Malloy {
      * instead of looping forever, but the fix is to correct the dialect.
      */
     static safelyFetchTableSchema(connection: InfoConnection, toFetch: Record<string, string>, opts: FetchSchemaOptions): Promise<{
-        schemas: Record<string, import("./model").TableSourceDef>;
+        schemas: Record<string, TableSourceDef>;
         errors: Record<string, string>;
     }>;
     /**
@@ -618,6 +627,11 @@ export declare class Explore extends Entity implements Taggable {
     toJSON(): SerializedExplore;
     static fromJSON(main_explore: SerializedExplore): Explore;
     get location(): DocumentLocation | undefined;
+    private collectSourceComponents;
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHAGE WITHOUT NOTICE
+     */
+    getSourceComponents(): SourceComponentInfo[];
 }
 export declare enum AtomicFieldType {
     String = "string",

package/dist/malloy.js

@@ -33,6 +33,11 @@ const annotation_1 = require("./annotation");
 const sql_block_1 = require("./model/sql_block");
 const utils_1 = require("./lang/utils");
 const reference_list_1 = require("./lang/reference-list");
+function isSourceComponent(source) {
+    return (source.type === 'table' ||
+        source.type === 'sql_select' ||
+        source.type === 'query_source');
+}
 const MALLOY_INTERNAL_URL = 'internal://internal.malloy';
 class Malloy {
     static get version() {
@@ -499,7 +504,7 @@ class Model {
      */
     getExploreByName(name) {
         const struct = this.modelDef.contents[name];
-        if ((0, model_1.isSourceDef)(struct)) {
+        if (struct && (0, model_1.isSourceDef)(struct)) {
             return new Explore(struct);
         }
         throw new Error("'name' is not an explore");
@@ -1268,6 +1273,82 @@ class Explore extends Entity {
     get location() {
         return this.structDef.location;
     }
+    collectSourceComponents(structDef) {
+        const sources = [];
+        if (structDef.type === 'composite') {
+            for (const source of structDef.sources) {
+                sources.push(...this.collectSourceComponents(source));
+            }
+            return sources;
+        }
+        if (isSourceComponent(structDef)) {
+            if (structDef.type === 'table') {
+                // Generate sourceID based on connection and table name
+                sources.push({
+                    type: 'table',
+                    tableName: structDef.tablePath,
+                    sourceID: `${structDef.connection}:${structDef.tablePath}`,
+                });
+            }
+            else if (structDef.type === 'sql_select') {
+                sources.push({
+                    type: 'sql',
+                    selectStatement: structDef.selectStr,
+                    sourceID: `${structDef.connection}:${structDef.selectStr}`,
+                });
+            }
+            else if (structDef.type === 'query_source') {
+                // For QuerySourceDef, we need to extract the SQL from the query
+                // We need to create a PreparedQuery from the query, then get a PreparedResult
+                // to access the SQL
+                let sql;
+                try {
+                    // Create a PreparedQuery from the query in the QuerySourceDef
+                    const preparedQuery = new PreparedQuery(structDef.query, this.modelDef, []);
+                    // Get the PreparedResult which contains the SQL
+                    const preparedResult = preparedQuery.getPreparedResult();
+                    // Extract the SQL
+                    sql = preparedResult.sql;
+                }
+                catch (error) {
+                    // If we can't compile the query, use a placeholder
+                    sql = `-- Could not compile SQL for query ${structDef.query.name || 'unnamed query'}: ${error instanceof Error ? error.message : String(error)}`;
+                }
+                // Generate sourceID based on connection and SQL
+                const sourceID = `${structDef.connection}:${sql}`;
+                sources.push({
+                    type: 'sql',
+                    selectStatement: sql,
+                    sourceID: sourceID,
+                });
+            }
+        }
+        else {
+            return [];
+        }
+        // Process all fields to find joins
+        for (const field of structDef.fields) {
+            if ((0, model_1.isJoined)(field)) {
+                sources.push(...this.collectSourceComponents(field));
+            }
+        }
+        return sources;
+    }
+    /**
+     * THIS IS A HIGHLY EXPERIMENTAL API AND MAY VANISH OR CHAGE WITHOUT NOTICE
+     */
+    getSourceComponents() {
+        const uniqueSources = {};
+        if ((0, model_1.isSourceDef)(this.structDef)) {
+            const allSources = this.collectSourceComponents(this.structDef);
+            // Deduplicate sources using sourceID as the key
+            for (const source of allSources) {
+                uniqueSources[source.sourceID] = source;
+            }
+        }
+        // Return the deduplicated sources as an array
+        return Object.values(uniqueSources);
+    }
 }
 exports.Explore = Explore;
 var AtomicFieldType;

package/dist/model/composite_source_utils.d.ts

@@ -1,5 +1,6 @@
+import type { BooleanFilter, NumberFilter, StringFilter, TemporalFilter } from '@malloydata/malloy-filter';
 import type { MalloyElement } from '../lang/ast';
-import type { FieldUsage, PipeSegment, SourceDef, StructDef, RequiredGroupBy } from './malloy_types';
+import type { FieldUsage, PipeSegment, SourceDef, Expr, StructDef, RequiredGroupBy } from './malloy_types';
 type CompositeCouldNotFindFieldError = {
     code: 'could_not_find_field';
     data: {
@@ -86,4 +87,17 @@ export declare function pathBegins(path: string[], prefix: string[]): boolean;
 export declare function sortFieldUsageByReferenceLocation(usage: FieldUsage[]): FieldUsage[];
 export declare function hasCompositesAnywhere(source: StructDef): boolean;
 export declare function logCompositeError(error: CompositeError, logTo: MalloyElement): void;
+export declare function compileFilterExpression(ft: string, fexpr: Expr): {
+    kind: 'date' | 'timestamp';
+    parsed: TemporalFilter;
+} | {
+    kind: 'string';
+    parsed: StringFilter;
+} | {
+    kind: 'boolean';
+    parsed: BooleanFilter;
+} | {
+    kind: 'number';
+    parsed: NumberFilter;
+} | undefined;
 export {};

package/dist/model/composite_source_utils.js

@@ -24,6 +24,8 @@ exports.pathBegins = pathBegins;
 exports.sortFieldUsageByReferenceLocation = sortFieldUsageByReferenceLocation;
 exports.hasCompositesAnywhere = hasCompositesAnywhere;
 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");
 function _resolveCompositeSources(path, source, rootFields, nests, fieldUsage, 
@@ -505,6 +507,7 @@ function getFieldUsageForField(field) {
     return [];
 }
 function nestLevelsAt(nests, at) {
+    var _a;
     if (at === undefined)
         return nests;
     return {
@@ -512,7 +515,8 @@ function nestLevelsAt(nests, at) {
         nested: nests.nested.map(n => nestLevelsAt(n, at)),
         fieldsReferenced: fieldUsageAt(nests.fieldsReferencedDirectly, at),
         ungroupings: ungroupingsAt(nests.ungroupings, at),
-        requiredGroupBys: requiredGroupBysAt(nests.requiredGroupBys, at),
+        requiredGroupBys: (_a = requiredGroupBysAt(nests.requiredGroupBys, at)) !== null && _a !== void 0 ? _a : [],
+        singleValueFilters: nests.singleValueFilters,
     };
 }
 function fieldUsageAt(fieldUsage, at) {
@@ -552,12 +556,13 @@ function joinedUngroupings(joinPath, ungroupings) {
     }));
 }
 function extractNestLevels(segment) {
-    var _a, _b;
+    var _a, _b, _c;
     const fieldsReferencedDirectly = [];
     const fieldsReferenced = [];
     const nested = [];
     const ungroupings = [];
     const requiredGroupBys = [];
+    const singleValueFilters = [];
     if (segment.type === 'project' ||
         segment.type === 'partial' ||
         segment.type === 'reduce') {
@@ -580,6 +585,12 @@ function extractNestLevels(segment) {
                 requiredGroupBys.push(...((_b = field.requiresGroupBy) !== null && _b !== void 0 ? _b : []));
             }
         }
+        for (const filter of (_c = segment.filterList) !== null && _c !== void 0 ? _c : []) {
+            if (!(0, malloy_types_1.expressionIsScalar)(filter.expressionType))
+                continue;
+            const fields = getSingleValueFilterFields(filter.e);
+            singleValueFilters.push(...fields);
+        }
     }
     const levels = {
         fieldsReferencedDirectly,
@@ -587,9 +598,70 @@ function extractNestLevels(segment) {
         fieldsReferenced,
         ungroupings,
         requiredGroupBys,
+        singleValueFilters,
     };
     return nestLevelsAt(levels, segment.referencedAt);
 }
+function getSingleValueFilterFields(filter) {
+    const fieldPaths = [];
+    if (filter.node === 'and') {
+        fieldPaths.push(...getSingleValueFilterFields(filter.kids.left));
+        fieldPaths.push(...getSingleValueFilterFields(filter.kids.right));
+    }
+    else if (filter.node === '()') {
+        fieldPaths.push(...getSingleValueFilterFields(filter.e));
+    }
+    else {
+        const path = isSingleValueFilterNode(filter);
+        if (path) {
+            fieldPaths.push(path);
+        }
+    }
+    return fieldPaths;
+}
+function isSingleValueFilterNode(e) {
+    if (e.node === 'filterMatch') {
+        if (e.kids.expr.node === 'field') {
+            const result = compileFilterExpression(e.dataType, e.kids.filterExpr);
+            if (!result)
+                return [];
+            if ((result.parsed.operator === 'null' && !result.parsed.not) ||
+                (result.kind === 'boolean' &&
+                    ['false', 'true'].includes(result.parsed.operator) &&
+                    !result.parsed.not) ||
+                (result.kind === 'date' &&
+                    result.parsed.operator === 'in' &&
+                    result.parsed.in.moment === 'literal' &&
+                    result.parsed.in.units === 'day' &&
+                    !result.parsed.not) ||
+                (result.kind === 'timestamp' &&
+                    result.parsed.operator === 'in' &&
+                    result.parsed.in.moment === 'literal' &&
+                    result.parsed.in.units === undefined &&
+                    !result.parsed.not) ||
+                // TODO: handle 'today', 'now', 'yesterday', etc.
+                ((result.kind === 'number' || result.kind === 'string') &&
+                    result.parsed.operator === '=' &&
+                    result.parsed.values.length === 1 &&
+                    !result.parsed.not)) {
+                return e.kids.expr.path;
+            }
+        }
+    }
+    else if (e.node === '=') {
+        if (e.kids.left.node === 'field' &&
+            (e.kids.right.node === 'true' ||
+                e.kids.right.node === 'false' ||
+                e.kids.right.node === 'timeLiteral' ||
+                e.kids.right.node === 'numberLiteral' ||
+                e.kids.right.node === 'stringLiteral')) {
+            return e.kids.left.path;
+        }
+    }
+    else if (e.node === 'is-null' && e.e.node === 'field') {
+        return e.e.path;
+    }
+}
 function expandRefs(nests, fields) {
     var _a, _b, _c;
     const newNests = [];
@@ -655,6 +727,7 @@ function expandRefs(nests, fields) {
             ungroupings: [],
             nested: [],
             requiredGroupBys: (_a = ungrouping.requiresGroupBy) !== null && _a !== void 0 ? _a : [],
+            singleValueFilters: [],
         }, fields);
         missingFields.push(...((_b = expanded.missingFields) !== null && _b !== void 0 ? _b : []));
         for (const field of expanded.result.requiredGroupBys) {
@@ -676,6 +749,7 @@ function expandRefs(nests, fields) {
             requiredGroupBys,
             unsatisfiableGroupBys,
             nested,
+            singleValueFilters: nests.singleValueFilters,
         },
         missingFields: missingFields.length > 0 ? missingFields : undefined,
     };
@@ -700,13 +774,16 @@ function checkRequiredGroupBys(compositeResolvedSourceDef, segment) {
     return unsatisfied;
 }
 function getUnsatisfiedRequiredGroupBys(level) {
-    const fields = level.fieldsReferencedDirectly;
+    const fields = [
+        ...level.fieldsReferencedDirectly.map(f => f.path),
+        ...level.singleValueFilters,
+    ];
     const requiredGroupBys = [...level.requiredGroupBys];
     for (const nested of level.nested) {
         requiredGroupBys.push(...getUnsatisfiedRequiredGroupBys(nested));
     }
     return [
-        ...requiredGroupBys.filter(rgb => !fields.some(f => pathEq(f.path, rgb.path))),
+        ...requiredGroupBys.filter(rgb => !fields.some(f => pathEq(f, rgb.path))),
         ...level.unsatisfiableGroupBys,
     ];
 }
@@ -803,7 +880,7 @@ function logCompositeError(error, logTo) {
                     }
                     else if (issue.type === 'missing-required-group-by') {
                         const fieldRef = `\`${issue.requiredGroupBy.path.join('.')}\``;
-                        logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: missing group by ${fieldRef} as required in ${source}${requiredFields}`, { at: issue.requiredGroupBy.at });
+                        logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: missing group by or single value filter of ${fieldRef} as required in ${source}${requiredFields}`, { at: issue.requiredGroupBy.at });
                     }
                     else {
                         const joinRef = `\`${issue.path.join('.')}\``;
@@ -817,4 +894,31 @@ function logCompositeError(error, logTo) {
         logTo.logError('could-not-resolve-composite-source', 'Could not resolve composite source');
     }
 }
+function compileFilterExpression(ft, fexpr) {
+    if (fexpr.node !== 'filterLiteral') {
+        return undefined;
+    }
+    const fsrc = fexpr.filterSrc;
+    if (ft === 'date' || ft === 'timestamp') {
+        const result = malloy_filter_1.TemporalFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    else if (ft === 'string') {
+        const result = malloy_filter_1.StringFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    else if (ft === 'number') {
+        const result = malloy_filter_1.NumberFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    else if (ft === 'boolean') {
+        const result = malloy_filter_1.BooleanFilterExpression.parse(fsrc);
+        if (result.parsed)
+            return { kind: ft, parsed: result.parsed };
+    }
+    return undefined;
+}
 //# sourceMappingURL=composite_source_utils.js.map

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.288";
+export declare const MALLOY_VERSION = "0.0.290";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.288",
+  "version": "0.0.290",
   "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.288",
-    "@malloydata/malloy-interfaces": "0.0.288",
-    "@malloydata/malloy-tag": "0.0.288",
+    "@malloydata/malloy-filter": "0.0.290",
+    "@malloydata/malloy-interfaces": "0.0.290",
+    "@malloydata/malloy-tag": "0.0.290",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",