@malloydata/malloy 0.0.215 → 0.0.216-dev241118202522

package/dist/model/composite_source_utils.js

@@ -0,0 +1,279 @@
+"use strict";
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compositeFieldUsageJoinPaths = exports.joinedCompositeFieldUsage = exports.compositeFieldUsageDifference = exports.emptyCompositeFieldUsage = exports.mergeCompositeFieldUsage = exports.unique = exports.formatCompositeFieldUsage = exports.compositeFieldUsageIsPlural = exports.isEmptyCompositeFieldUsage = exports.formatCompositeFieldUsages = exports.compositeFieldUsagePaths = exports.resolveCompositeSources = exports.narrowCompositeFieldResolution = exports.emptyNarrowedCompositeFieldResolution = void 0;
+const utils_1 = require("../lang/utils");
+const malloy_types_1 = require("./malloy_types");
+function _resolveCompositeSources(path, source, compositeFieldUsage, narrowedCompositeFieldResolution = undefined) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    let base = { ...source };
+    let narrowedSources = undefined;
+    if (compositeFieldUsage.fields.length > 0) {
+        if (source.type === 'composite') {
+            let found = false;
+            // The narrowed source list is either the one given when this function was called,
+            // or we construct a new one from the given composite source's input sources.
+            narrowedSources =
+                (_a = narrowedCompositeFieldResolution === null || narrowedCompositeFieldResolution === void 0 ? void 0 : narrowedCompositeFieldResolution.source) !== null && _a !== void 0 ? _a : source.sources.map(s => ({ source: s, nested: undefined }));
+            // Make a copy, which we will mutate: if a source is invalid, we remove it from the list
+            // and move on; if the source is a nested composite source, we narrow the resolution of
+            // the inner sources and update the element in the list
+            const newNarrowedSources = [...narrowedSources];
+            // We iterate over the list of narrowed sources;
+            overSources: for (const { source: inputSource, nested, } of narrowedSources) {
+                const fieldNames = new Set();
+                for (const field of inputSource.fields) {
+                    fieldNames.add((_b = field.as) !== null && _b !== void 0 ? _b : field.name);
+                }
+                for (const usage of compositeFieldUsage.fields) {
+                    if (!fieldNames.has(usage)) {
+                        newNarrowedSources.shift();
+                        continue overSources;
+                    }
+                }
+                const nonCompositeFields = getNonCompositeFields(source);
+                if (inputSource.type === 'composite') {
+                    const resolveInner = _resolveCompositeSources(path, inputSource, compositeFieldUsageWithoutNonCompositeFields(compositeFieldUsage, inputSource), 
+                    // This looks wonky, but what we're doing is taking the nested sources
+                    // and "promoting" them to look like they're top level sources; we will
+                    // then reverse this when we update the real narrowed resolution.
+                    {
+                        source: nested !== null && nested !== void 0 ? nested : inputSource.sources.map(s => ({ source: s, nested: [] })),
+                        // Composite source inputs cannot have joins, so we don't need to
+                        // pass in the narrowed resolution
+                        joined: {},
+                    });
+                    if ('error' in resolveInner) {
+                        newNarrowedSources.shift();
+                        continue overSources;
+                    }
+                    base = { ...resolveInner.success };
+                    newNarrowedSources[0] = {
+                        source: inputSource,
+                        nested: resolveInner.narrowedCompositeFieldResolution.source,
+                    };
+                }
+                else {
+                    base = { ...inputSource };
+                }
+                found = true;
+                base = {
+                    ...base,
+                    fields: [...nonCompositeFields, ...base.fields],
+                    filterList: [
+                        ...((_c = source.filterList) !== null && _c !== void 0 ? _c : []),
+                        ...((_d = base.filterList) !== null && _d !== void 0 ? _d : []),
+                    ],
+                };
+                break;
+            }
+            if (!found) {
+                return {
+                    error: {
+                        code: 'no_suitable_composite_source_input',
+                        data: { fields: compositeFieldUsage.fields, path },
+                    },
+                };
+            }
+            narrowedSources = newNarrowedSources;
+        }
+        else {
+            return { error: { code: 'not_a_composite_source', data: { path } } };
+        }
+    }
+    const fieldsByName = {};
+    const narrowedJoinedSources = (_e = narrowedCompositeFieldResolution === null || narrowedCompositeFieldResolution === void 0 ? void 0 : narrowedCompositeFieldResolution.joined) !== null && _e !== void 0 ? _e : {};
+    for (const field of base.fields) {
+        fieldsByName[(_f = field.as) !== null && _f !== void 0 ? _f : field.name] = field;
+    }
+    for (const [joinName, joinedUsage] of Object.entries(compositeFieldUsage.joinedUsage)) {
+        const join = fieldsByName[joinName];
+        const newPath = [...path, joinName];
+        if (join === undefined) {
+            return {
+                error: { code: 'composite_source_not_defined', data: { path: newPath } },
+            };
+        }
+        if (!(0, malloy_types_1.isJoined)(join) || !(0, malloy_types_1.isSourceDef)(join)) {
+            return {
+                error: { code: 'composite_source_not_a_join', data: { path: newPath } },
+            };
+        }
+        const resolved = _resolveCompositeSources(newPath, join, joinedUsage, narrowedJoinedSources[joinName]);
+        if ('error' in resolved) {
+            return resolved;
+        }
+        if (!(0, malloy_types_1.isJoinable)(resolved.success)) {
+            return {
+                error: {
+                    code: 'composite_source_is_not_joinable',
+                    data: { path: newPath },
+                },
+            };
+        }
+        fieldsByName[joinName] = {
+            ...resolved.success,
+            join: join.join,
+            as: (_g = join.as) !== null && _g !== void 0 ? _g : join.name,
+            onExpression: join.onExpression,
+        };
+        narrowedJoinedSources[joinName] = resolved.narrowedCompositeFieldResolution;
+    }
+    return {
+        success: { ...base, fields: Object.values(fieldsByName) },
+        narrowedCompositeFieldResolution: {
+            source: narrowedSources,
+            joined: narrowedJoinedSources,
+        },
+    };
+}
+function emptyNarrowedCompositeFieldResolution() {
+    return { source: undefined, joined: {} };
+}
+exports.emptyNarrowedCompositeFieldResolution = emptyNarrowedCompositeFieldResolution;
+// Should always give the _full_ `compositeFieldUsage`, because we only
+// cross off sources until we find one that works, but that does not
+// guarantee that all the remaining sources will work.
+function narrowCompositeFieldResolution(source, compositeFieldUsage, narrowedCompositeFieldResolution) {
+    const result = _resolveCompositeSources([], source, compositeFieldUsage, narrowedCompositeFieldResolution);
+    if ('success' in result) {
+        return {
+            narrowedCompositeFieldResolution: result.narrowedCompositeFieldResolution,
+            error: undefined,
+        };
+    }
+    return { narrowedCompositeFieldResolution: undefined, error: result.error };
+}
+exports.narrowCompositeFieldResolution = narrowCompositeFieldResolution;
+function resolveCompositeSources(source, compositeFieldUsage) {
+    const result = _resolveCompositeSources([], source, compositeFieldUsage);
+    if ('success' in result) {
+        return { sourceDef: result.success, error: undefined };
+    }
+    return { sourceDef: undefined, error: result.error };
+}
+exports.resolveCompositeSources = resolveCompositeSources;
+function compositeFieldUsagePaths(compositeFieldUsage) {
+    return [
+        ...compositeFieldUsage.fields.map(f => [f]),
+        ...Object.entries(compositeFieldUsage.joinedUsage)
+            .map(([joinName, joinedUsage]) => compositeFieldUsagePaths(joinedUsage).map(path => [joinName, ...path]))
+            .flat(),
+    ];
+}
+exports.compositeFieldUsagePaths = compositeFieldUsagePaths;
+function formatCompositeFieldUsages(compositeFieldUsage) {
+    return compositeFieldUsagePaths(compositeFieldUsage)
+        .map(compositeFieldUsage => formatCompositeFieldUsage(compositeFieldUsage))
+        .join(', ');
+}
+exports.formatCompositeFieldUsages = formatCompositeFieldUsages;
+function countCompositeFieldUsage(compositeFieldUsage) {
+    return Object.values(compositeFieldUsage.joinedUsage).reduce((a, b) => a + countCompositeFieldUsage(b), compositeFieldUsage.fields.length);
+}
+function isEmptyCompositeFieldUsage(compositeFieldUsage) {
+    return countCompositeFieldUsage(compositeFieldUsage) === 0;
+}
+exports.isEmptyCompositeFieldUsage = isEmptyCompositeFieldUsage;
+function compositeFieldUsageIsPlural(compositeFieldUsage) {
+    return countCompositeFieldUsage(compositeFieldUsage) > 1;
+}
+exports.compositeFieldUsageIsPlural = compositeFieldUsageIsPlural;
+function formatCompositeFieldUsage(compositeFieldUsage) {
+    return `\`${compositeFieldUsage.join('.')}\``;
+}
+exports.formatCompositeFieldUsage = formatCompositeFieldUsage;
+function unique(values) {
+    return Array.from(new Set(values));
+}
+exports.unique = unique;
+function mergeCompositeFieldUsage(...usages) {
+    const nonEmptyUsages = usages.filter(utils_1.isNotUndefined);
+    const joinNames = new Set(nonEmptyUsages.map(u => Object.keys(u.joinedUsage)).flat());
+    const joinedUsage = {};
+    for (const joinName of joinNames) {
+        joinedUsage[joinName] = mergeCompositeFieldUsage(...nonEmptyUsages
+            .map(u => u === null || u === void 0 ? void 0 : u.joinedUsage[joinName])
+            .filter(utils_1.isNotUndefined));
+    }
+    return {
+        fields: unique(nonEmptyUsages.map(u => u.fields).flat()),
+        joinedUsage,
+    };
+}
+exports.mergeCompositeFieldUsage = mergeCompositeFieldUsage;
+function emptyCompositeFieldUsage() {
+    return { fields: [], joinedUsage: {} };
+}
+exports.emptyCompositeFieldUsage = emptyCompositeFieldUsage;
+function arrayDifference(a, b) {
+    const bSet = new Set(b);
+    const ret = [];
+    for (const value of a) {
+        if (bSet.has(value))
+            continue;
+        ret.push(value);
+    }
+    return ret;
+}
+// Return all of `a`'s usage without any of `b`'s usage
+function compositeFieldUsageDifference(a, b) {
+    return {
+        fields: arrayDifference(a.fields, b.fields),
+        joinedUsage: Object.fromEntries(Object.entries(a.joinedUsage)
+            .map(([joinName, joinedUsage]) => [
+            joinName,
+            joinName in b.joinedUsage
+                ? compositeFieldUsageDifference(joinedUsage, b.joinedUsage[joinName])
+                : joinedUsage,
+        ])
+            .filter(([_, joinedUsage]) => countCompositeFieldUsage(joinedUsage) > 0)),
+    };
+}
+exports.compositeFieldUsageDifference = compositeFieldUsageDifference;
+function joinedCompositeFieldUsage(joinPath, compositeFieldUsage) {
+    if (joinPath.length === 0)
+        return compositeFieldUsage;
+    return joinedCompositeFieldUsage(joinPath.slice(0, -1), {
+        fields: [],
+        joinedUsage: { [joinPath[joinPath.length - 1]]: compositeFieldUsage },
+    });
+}
+exports.joinedCompositeFieldUsage = joinedCompositeFieldUsage;
+function compositeFieldUsageJoinPaths(compositeFieldUsage) {
+    const joinsUsed = Object.keys(compositeFieldUsage.joinedUsage);
+    return [
+        ...joinsUsed.map(joinName => [joinName]),
+        ...joinsUsed
+            .map(joinName => compositeFieldUsageJoinPaths(compositeFieldUsage.joinedUsage[joinName]).map(path => [joinName, ...path]))
+            .flat(),
+    ];
+}
+exports.compositeFieldUsageJoinPaths = compositeFieldUsageJoinPaths;
+function isCompositeField(fieldDef) {
+    var _a;
+    return 'e' in fieldDef && ((_a = fieldDef.e) === null || _a === void 0 ? void 0 : _a.node) === 'compositeField';
+}
+function getNonCompositeFields(source) {
+    return source.fields.filter(f => !isCompositeField(f));
+}
+// This is specifically for the case where the source `source` is a composite and the chosen input
+// source is also a composite; if the `source` defines some fields outright, when resolving the inner
+// composite, we don't want to include those fields.
+function compositeFieldUsageWithoutNonCompositeFields(compositeFieldUsage, source) {
+    var _a;
+    const sourceFieldsByName = {};
+    for (const field of source.fields) {
+        sourceFieldsByName[(_a = field.as) !== null && _a !== void 0 ? _a : field.name] = field;
+    }
+    return {
+        fields: compositeFieldUsage.fields.filter(f => isCompositeField(sourceFieldsByName[f])),
+        joinedUsage: compositeFieldUsage.joinedUsage,
+    };
+}
+//# sourceMappingURL=composite_source_utils.js.map

package/dist/model/malloy_query.d.ts

@@ -1,5 +1,5 @@
 import { Dialect, DialectFieldList } from '../dialect';
-import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, Parameter, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, AtomicFieldDef, BooleanFieldDef, QueryToMaterialize, PrepareResultOptions, CaseExpr } from './malloy_types';
+import { AggregateFunctionType, Annotation, CompiledQuery, Expr, FieldDef, Filtered, FunctionOverloadDef, FunctionParameterDef, JoinRelationship, ModelDef, OrderBy, OutputFieldNode, ParameterNode, PipeSegment, Query, QueryFieldDef, QuerySegment, ResultMetadataDef, ResultStructMetadataDef, SearchIndexResult, SegmentFieldDef, StructDef, StructRef, TurtleDef, FunctionOrderBy, Argument, AggregateExpr, FilterCondition, GenericSQLExpr, FieldnameNode, FunctionCallNode, UngroupNode, SourceReferenceNode, SpreadExpr, FilteredExpr, SourceDef, AtomicFieldDef, BooleanFieldDef, QueryToMaterialize, PrepareResultOptions, CaseExpr } from './malloy_types';
 import { Connection } from '../connection/types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
@@ -308,10 +308,10 @@ declare class QueryStruct extends QueryNode {
     connectionName: string;
     constructor(structDef: StructDef, sourceArguments: Record<string, Argument> | undefined, parent: ParentQueryStruct | ParentQueryModel, prepareResultOptions: PrepareResultOptions, referenceId?: string);
     maybeEmitParameterizedSourceUsage(): void;
-    resolveParentParameterReferences(param: Parameter): Parameter;
+    private resolveParentParameterReferences;
     private _arguments;
     arguments(): Record<string, Argument>;
-    addFieldsFromFieldList(fields: FieldDef[]): void;
+    private addFieldsFromFieldList;
     getAliasIdentifier(): string;
     getSQLIdentifier(): string;
     getIdentifier(): string;

package/dist/model/malloy_query.js

@@ -878,6 +878,8 @@ class QueryField extends QueryNode {
             case 'functionDefaultOrderBy':
             case 'functionOrderBy':
                 return '';
+            case 'compositeField':
+                return '{COMPOSITE_FIELD}';
             default:
                 throw new Error(`Internal Error: Unknown expression node '${expr.node}' ${JSON.stringify(expr, undefined, 2)}`);
         }
@@ -3279,6 +3281,8 @@ class QueryStruct extends QueryNode {
         switch (this.structDef.type) {
             case 'table':
                 return this.dialect.quoteTablePath(this.structDef.tablePath);
+            case 'composite':
+                return '{COMPOSITE SOURCE}';
             case 'finalize':
                 return this.structDef.name;
             case 'sql_select':
@@ -3457,6 +3461,7 @@ class QueryModel {
         return new QueryStruct(structRef, sourceArguments, { model: this }, prepareResultOptions);
     }
     loadQuery(query, stageWriter, prepareResultOptions, emitFinalStage = false, isJoinedSubquery = false) {
+        var _a;
         const malloy = '';
         if (!stageWriter) {
             stageWriter = new StageWriter(true, undefined);
@@ -3467,7 +3472,8 @@ class QueryModel {
             pipeline: query.pipeline,
             filterList: query.filterList,
         };
-        const q = QueryQuery.makeQuery(turtleDef, this.getStructFromRef(query.structRef, query.sourceArguments, prepareResultOptions), stageWriter, isJoinedSubquery);
+        const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
+        const q = QueryQuery.makeQuery(turtleDef, this.getStructFromRef(structRef, query.sourceArguments, prepareResultOptions), stageWriter, isJoinedSubquery);
         const ret = q.generateSQLFromPipeline(stageWriter);
         if (emitFinalStage && q.parent.dialect.hasFinalStage) {
             // const fieldNames: string[] = [];
@@ -3486,13 +3492,14 @@ class QueryModel {
         };
     }
     compileQuery(query, prepareResultOptions, finalize = true) {
-        var _a;
+        var _a, _b;
         let newModel;
         const m = newModel || this;
         const ret = m.loadQuery(query, undefined, prepareResultOptions, finalize, false);
-        const sourceExplore = typeof query.structRef === 'string'
-            ? query.structRef
-            : query.structRef.as || query.structRef.name;
+        const structRef = (_a = query.compositeResolvedSourceDef) !== null && _a !== void 0 ? _a : query.structRef;
+        const sourceExplore = typeof structRef === 'string'
+            ? structRef
+            : structRef.as || structRef.name;
         // LTNote:  I don't understand why this might be here.  It should have happened in loadQuery...
         if (finalize && this.dialect.hasFinalStage) {
             ret.lastStageName = ret.stageWriter.addStage(
@@ -3505,7 +3512,7 @@ class QueryModel {
             sql: ret.stageWriter.generateSQLStages(),
             dependenciesToMaterialize: ret.stageWriter.dependenciesToMaterialize,
             materialization: (0, utils_2.shouldMaterialize)(query.annotation)
-                ? (0, utils_2.buildQueryMaterializationSpec)((_a = query.location) === null || _a === void 0 ? void 0 : _a.url, query.name, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.materializedTablePrefix)
+                ? (0, utils_2.buildQueryMaterializationSpec)((_b = query.location) === null || _b === void 0 ? void 0 : _b.url, query.name, prepareResultOptions === null || prepareResultOptions === void 0 ? void 0 : prepareResultOptions.materializedTablePrefix)
                 : undefined,
             structs: ret.structs,
             sourceExplore,

package/dist/model/malloy_types.d.ts

@@ -24,7 +24,7 @@ export type AnyExpr = ExprE | ExprOptionalE | ExprWithKids | ExprLeaf;
 export declare function exprHasKids(e: AnyExpr): e is ExprWithKids;
 export declare function exprHasE(e: AnyExpr): e is ExprE;
 export declare function exprIsLeaf(e: AnyExpr): boolean;
-export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | TimeLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | ErrorNode;
+export type Expr = BinaryExpr | UnaryExpr | FunctionCallNode | OutputFieldNode | FilterCondition | FilteredExpr | AggregateExpr | EmptyExpr | UngroupNode | FunctionParameterNode | SpreadExpr | AggregateOrderByNode | AggregateLimitNode | FieldnameNode | SourceReferenceNode | ParameterNode | NowNode | MeasureTimeExpr | TimeExtractExpr | TimeDeltaExpr | TimeTruncExpr | TimeLiteralNode | TypecastExpr | RegexMatchExpr | RegexLiteralNode | StringLiteralNode | NumberLiteralNode | BooleanLiteralNode | RecordLiteralNode | ArrayLiteralNode | FunctionOrderBy | GenericSQLExpr | NullNode | CaseExpr | InCompareExpr | CompositeFieldExpr | ErrorNode;
 interface HasTypeDef {
     typeDef: AtomicTypeDef;
 }
@@ -63,6 +63,7 @@ export interface FilterCondition extends ExprE {
     node: 'filterCondition';
     code: string;
     expressionType: ExpressionType;
+    compositeFieldUsage?: CompositeFieldUsage;
 }
 export interface FilteredExpr extends ExprWithKids {
     node: 'filteredExpr';
@@ -227,6 +228,9 @@ export interface CaseExpr extends ExprWithKids {
         caseElse?: Expr;
     };
 }
+export interface CompositeFieldExpr extends ExprLeaf {
+    node: 'compositeField';
+}
 export interface InCompareExpr extends ExprWithKids {
     node: 'in';
     not: boolean;
@@ -238,6 +242,7 @@ export interface InCompareExpr extends ExprWithKids {
 export type ExpressionType = 'scalar' | 'aggregate' | 'scalar_analytic' | 'aggregate_analytic' | 'ungrouped_aggregate';
 export interface Expression {
     e?: Expr;
+    compositeFieldUsage?: CompositeFieldUsage;
     expressionType?: ExpressionType;
     code?: string;
 }
@@ -410,6 +415,7 @@ export interface JoinBase {
     join: JoinType;
     matrixOperation?: MatrixOperation;
     onExpression?: Expr;
+    onCompositeFieldUsage?: CompositeFieldUsage;
 }
 export type Joinable = TableSourceDef | SQLSourceDef | QuerySourceDef | RecordFieldDef | ArrayDef;
 export type JoinFieldDef = JoinBase & Joinable;
@@ -492,6 +498,7 @@ export interface Query extends Pipeline, Filtered, HasLocation {
     sourceArguments?: Record<string, Argument>;
     annotation?: Annotation;
     modelAnnotation?: Annotation;
+    compositeResolvedSourceDef?: SourceDef;
 }
 export type NamedQuery = Query & NamedObject;
 export type PipeSegment = QuerySegment | IndexSegment | RawSegment;
@@ -539,6 +546,10 @@ export interface IndexSegment extends Filtered {
     alwaysJoins?: string[];
 }
 export declare function isIndexSegment(pe: PipeSegment): pe is IndexSegment;
+export interface CompositeFieldUsage {
+    fields: string[];
+    joinedUsage: Record<string, CompositeFieldUsage>;
+}
 export interface QuerySegment extends Filtered {
     type: 'reduce' | 'project' | 'partial';
     queryFields: QueryFieldDef[];
@@ -548,6 +559,7 @@ export interface QuerySegment extends Filtered {
     orderBy?: OrderBy[];
     queryTimezone?: string;
     alwaysJoins?: string[];
+    compositeFieldUsage?: CompositeFieldUsage;
 }
 export interface TurtleDef extends NamedObject, Pipeline {
     type: 'turtle';
@@ -573,6 +585,10 @@ export interface TableSourceDef extends SourceDefBase {
     type: 'table';
     tablePath: string;
 }
+export interface CompositeSourceDef extends SourceDefBase {
+    type: 'composite';
+    sources: SourceDef[];
+}
 export interface SQLStringSegment {
     sql: string;
 }
@@ -603,7 +619,7 @@ export interface FinalizeSourceDef extends SourceDefBase {
 }
 export declare function sourceBase(sd: SourceDefBase): SourceDefBase;
 export declare function isSourceDef(sd: NamedModelObject | FieldDef): sd is SourceDef;
-export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryResultDef | FinalizeSourceDef | NestSourceDef;
+export type SourceDef = TableSourceDef | SQLSourceDef | QuerySourceDef | QueryResultDef | FinalizeSourceDef | NestSourceDef | CompositeSourceDef;
 /** Is this the "FROM" table of a query tree */
 export declare function isBaseTable(def: StructDef): def is SourceDef;
 export declare function isScalarArray(def: FieldDef | StructDef): boolean;
@@ -618,6 +634,7 @@ export type LeafExpressionType = Exclude<ExpressionValueType, JoinElementType |
 export type TypeInfo = {
     expressionType: ExpressionType;
     evalSpace: EvalSpace;
+    compositeFieldUsage: CompositeFieldUsage;
 };
 export type TypeDesc = ExpressionValueTypeDef & TypeInfo;
 export type FunctionParamType = ExpressionValueTypeDef | {

package/dist/model/malloy_types.js

@@ -178,7 +178,11 @@ function fieldIsIntrinsic(f) {
 exports.fieldIsIntrinsic = fieldIsIntrinsic;
 function arrayEachFields(arrayOf) {
     return [
-        { name: 'each', ...arrayOf, e: { node: 'field', path: ['value'] } },
+        {
+            name: 'each',
+            ...arrayOf,
+            e: { node: 'field', path: ['value'] },
+        },
         { name: 'value', ...arrayOf },
     ];
 }
@@ -192,7 +196,14 @@ function isMatrixOperation(x) {
 }
 exports.isMatrixOperation = isMatrixOperation;
 function isJoinable(sd) {
-    return ['table', 'sql_select', 'query_source', 'array', 'record'].includes(sd.type);
+    return [
+        'table',
+        'sql_select',
+        'query_source',
+        'array',
+        'record',
+        'composite',
+    ].includes(sd.type);
 }
 exports.isJoinable = isJoinable;
 function isJoined(fd) {
@@ -314,7 +325,8 @@ function isSourceDef(sd) {
         sd.type === 'query_source' ||
         sd.type === 'query_result' ||
         sd.type === 'finalize' ||
-        sd.type === 'nest_source');
+        sd.type === 'nest_source' ||
+        sd.type === 'composite');
 }
 exports.isSourceDef = isSourceDef;
 /** Is this the "FROM" table of a query tree */

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.215";
+export declare const MALLOY_VERSION = "0.0.216";

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.215",
+  "version": "0.0.216-dev241118202522",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",