@malloydata/malloy 0.0.271 → 0.0.273

package/dist/api/core.js

@@ -437,6 +437,21 @@ function statedCompileQuery(state) {
             const modelAnnotations = (0, annotation_1.annotationToTaglines)(result.modelDef.annotation).map(l => ({
                 value: l,
             }));
+            let source;
+            if (query.compositeResolvedSourceDef) {
+                source = query.compositeResolvedSourceDef;
+            }
+            else {
+                if ((0, model_1.refIsStructDef)(query.structRef)) {
+                    source = query.structRef;
+                }
+                else {
+                    source = result.modelDef.contents[query.structRef];
+                }
+            }
+            const sourceAnnotations = (0, annotation_1.annotationToTaglines)(source.annotation).map(l => ({
+                value: l,
+            }));
             annotations.push({
                 value: malloy_tag_1.Tag.withPrefix('#(malloy) ')
                     .set(['source_name'], translatedQuery.sourceExplore)
@@ -454,9 +469,10 @@ function statedCompileQuery(state) {
                     sql: translatedQuery.sql,
                     schema,
                     connection_name: translatedQuery.connectionName,
-                    annotations: annotations.length > 0 ? annotations : undefined,
-                    model_annotations: modelAnnotations.length > 0 ? modelAnnotations : undefined,
+                    annotations: annotationsOrUndefined(annotations),
+                    model_annotations: annotationsOrUndefined(modelAnnotations),
                     query_timezone: translatedQuery.queryTimezone,
+                    source_annotations: annotationsOrUndefined(sourceAnnotations),
                 },
                 default_row_limit_added: translatedQuery.defaultRowLimitAdded,
             };
@@ -480,4 +496,7 @@ function statedCompileQuery(state) {
     }
 }
 exports.statedCompileQuery = statedCompileQuery;
+function annotationsOrUndefined(annotations) {
+    return annotations.length > 0 ? annotations : undefined;
+}
 //# sourceMappingURL=core.js.map

package/dist/dialect/trino/dialect_functions.js

@@ -363,5 +363,26 @@ exports.PRESTO_DIALECT_FUNCTIONS = {
     ...(0, util_1.def)('array_sort_desc', { 'x': { array: T } }, { array: T }),
     ...(0, util_1.def)('remove_nulls', { 'x': { array: T } }, { array: T }),
     ...(0, util_1.def)('array_top_n', { 'x': { array: T }, 'n': 'number' }, { array: T }),
+    // presto with more parameters
+    hll_accumulate: {
+        default: {
+            takes: { 'value': { dimension: T } },
+            returns: { measure: { sql_native: 'hyperloglog' } },
+            generic: {
+                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+            },
+            isSymmetric: true,
+            impl: { sql: 'APPROX_SET(${value}, 0.0040625)' },
+        },
+        with_percent: {
+            takes: { 'value': { dimension: T }, 'accuracy': 'number' },
+            returns: { measure: { sql_native: 'hyperloglog' } },
+            generic: {
+                'T': ['string', 'number', 'date', 'timestamp', 'boolean', 'json'],
+            },
+            isSymmetric: true,
+            impl: { sql: 'APPROX_SET(${value}, 0.0040625)' },
+        },
+    },
 };
 //# sourceMappingURL=dialect_functions.js.map

package/dist/lang/ast/expressions/constant-expression.d.ts

@@ -1,4 +1,4 @@
-import type { StructDef } from '../../../model/malloy_types';
+import type { AccessModifierLabel, StructDef } from '../../../model/malloy_types';
 import type { BinaryMalloyOperator } from '../types/binary_operators';
 import type { ExprValue } from '../types/expr-value';
 import { ExpressionDef } from '../types/expression-def';
@@ -15,7 +15,7 @@ export declare class ConstantFieldSpace implements FieldSpace {
     dialectName(): string;
     dialectObj(): undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
-    isProtectedAccessSpace(): boolean;
+    accessProtectionLevel(): AccessModifierLabel;
 }
 export declare class ConstantExpression extends ExpressionDef {
     readonly expr: ExpressionDef;

package/dist/lang/ast/expressions/constant-expression.js

@@ -58,8 +58,8 @@ class ConstantFieldSpace {
     isQueryFieldSpace() {
         return false;
     }
-    isProtectedAccessSpace() {
-        return false;
+    accessProtectionLevel() {
+        return 'private';
     }
 }
 exports.ConstantFieldSpace = ConstantFieldSpace;

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

@@ -156,7 +156,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
             }
             // Add access modifiers at the end so views don't obey them
             for (const [name, access] of this.newAccessModifiers) {
-                const index = this.sourceDef.fields.findIndex(f => { var _a; return (_a = f.as) !== null && _a !== void 0 ? _a : f.name === name; });
+                const index = this.sourceDef.fields.findIndex(f => { var _a; return ((_a = f.as) !== null && _a !== void 0 ? _a : f.name) === name; });
                 if (index === -1) {
                     throw new Error(`Can't find field '${name}' to set access modifier`);
                 }

package/dist/lang/ast/field-space/include-utils.d.ts

@@ -0,0 +1,28 @@
+import type { AccessModifierLabel, Annotation, DocumentLocation, SourceDef } from '../../../model/malloy_types';
+import type { IncludeItem } from '../source-query-elements/include-item';
+import type { FieldReference } from '../query-items/field-references';
+export interface JoinIncludeProcessingState {
+    star: AccessModifierLabel | 'inherit' | 'except' | undefined;
+    starNote: Annotation | undefined;
+    fieldsIncluded: Set<string>;
+    joinNames: Set<string>;
+    fieldsExcepted: Set<string>;
+    allFields: Set<string>;
+    alreadyPrivateFields: Set<string>;
+    modifiers: Map<string, AccessModifierLabel>;
+    renames: {
+        as: string;
+        name: FieldReference;
+        location: DocumentLocation;
+    }[];
+    fieldsToInclude: Set<string> | undefined;
+    notes: Map<string, Annotation>;
+}
+export interface IncludeProcessingState {
+    joins: {
+        path: string[];
+        state: JoinIncludeProcessingState;
+    }[];
+}
+export declare function getIncludeStateForJoin(joinPath: string[], state: IncludeProcessingState): JoinIncludeProcessingState;
+export declare function processIncludeList(includeItems: IncludeItem[] | undefined, from: SourceDef): IncludeProcessingState;

package/dist/lang/ast/field-space/include-utils.js

@@ -0,0 +1,258 @@
+"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.processIncludeList = exports.getIncludeStateForJoin = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const include_item_1 = require("../source-query-elements/include-item");
+const field_references_1 = require("../query-items/field-references");
+const composite_source_utils_1 = require("../../../model/composite_source_utils");
+function getJoinFields(from, joinPath, logTo) {
+    let fields = from.fields;
+    for (const joinName of joinPath) {
+        const join = fields.find(f => { var _a; return ((_a = f.as) !== null && _a !== void 0 ? _a : f.name) === joinName; });
+        if (join === undefined) {
+            logTo.logError('field-not-found', `\`${joinName}\` not found`);
+            return [];
+        }
+        if (!(0, malloy_types_1.isJoined)(join)) {
+            logTo.logError('field-not-found', `\`${joinName}\` is not a join`);
+            return [];
+        }
+        fields = join.fields;
+    }
+    return fields;
+}
+function getIncludeStateForJoin(joinPath, state) {
+    const joinState = state.joins.find(s => (0, composite_source_utils_1.pathEq)(s.path, joinPath));
+    if (joinState !== undefined)
+        return joinState.state;
+    return {
+        star: undefined,
+        starNote: undefined,
+        joinNames: new Set(),
+        fieldsIncluded: new Set(),
+        fieldsExcepted: new Set(),
+        allFields: new Set(),
+        alreadyPrivateFields: new Set(),
+        modifiers: new Map(),
+        renames: [],
+        notes: new Map(),
+        fieldsToInclude: undefined,
+    };
+}
+exports.getIncludeStateForJoin = getIncludeStateForJoin;
+function getOrCreateIncludeStateForJoin(joinPath, state, from, logTo) {
+    const joinState = state.joins.find(s => (0, composite_source_utils_1.pathEq)(s.path, joinPath));
+    if (joinState !== undefined)
+        return joinState.state;
+    else {
+        const fromFields = getJoinFields(from, joinPath, logTo);
+        const allFields = new Set(fromFields.map(f => { var _a; return (_a = f.as) !== null && _a !== void 0 ? _a : f.name; }));
+        const joinNames = new Set(fromFields.filter(f => (0, malloy_types_1.isJoined)(f)).map(f => { var _a; return (_a = f.as) !== null && _a !== void 0 ? _a : f.name; }));
+        const alreadyPrivateFields = new Set(fromFields
+            .filter(f => f.accessModifier === 'private')
+            .map(f => { var _a; return (_a = f.as) !== null && _a !== void 0 ? _a : f.name; }));
+        const joinState = {
+            star: undefined,
+            joinNames,
+            starNote: undefined,
+            fieldsIncluded: new Set(),
+            fieldsExcepted: new Set(),
+            allFields,
+            alreadyPrivateFields,
+            modifiers: new Map(),
+            renames: [],
+            notes: new Map(),
+            fieldsToInclude: new Set(),
+        };
+        state.joins.push({ path: [...joinPath], state: joinState });
+        return joinState;
+    }
+}
+function checkParents(state, joinPath, from, f, kind) {
+    for (let prefixLength = 0; prefixLength < joinPath.length; prefixLength++) {
+        const parentPath = joinPath.slice(0, prefixLength);
+        const joinName = joinPath[prefixLength];
+        const parentState = getOrCreateIncludeStateForJoin(parentPath, state, from, f);
+        if (parentState.fieldsExcepted.has(joinName)) {
+            const action = kind === 'except' ? 'exclude' : 'include';
+            f.logError('include-after-exclude', `Cannot ${action} fields from \`${joinName}\` when \`${joinName}\` is itself excepted`);
+            continue;
+        }
+        else if (parentState.alreadyPrivateFields.has(joinName) ||
+            parentState.modifiers.get(joinName) === 'private') {
+            f.logError('field-not-accessible', `\`${joinName}\` is private`);
+            continue;
+        }
+        else if (kind === 'public') {
+            parentState.modifiers.set(joinName, 'public');
+        }
+        parentState.fieldsIncluded.add(joinName);
+    }
+}
+function processIncludeList(includeItems, from) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+    const state = { joins: [] };
+    if (includeItems === undefined) {
+        return state;
+    }
+    for (const item of includeItems) {
+        if (item instanceof include_item_1.IncludeAccessItem) {
+            for (const f of item.fields) {
+                const joinPath = f.name instanceof field_references_1.WildcardFieldReference
+                    ? (_b = (_a = f.name.joinPath) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : []
+                    : f.name.path.slice(0, -1);
+                const joinState = getOrCreateIncludeStateForJoin(joinPath, state, from, f);
+                checkParents(state, joinPath, from, f, item.kind);
+                if (f.name instanceof field_references_1.WildcardFieldReference) {
+                    if (joinState.star !== undefined) {
+                        item.logError('already-used-star-in-include', 'Wildcard already used in this include block');
+                    }
+                    else {
+                        joinState.star = (_c = item.kind) !== null && _c !== void 0 ? _c : 'inherit';
+                        joinState.starNote = {
+                            notes: (_e = (_d = f.note) === null || _d === void 0 ? void 0 : _d.notes) !== null && _e !== void 0 ? _e : [],
+                            blockNotes: (_g = (_f = item.note) === null || _f === void 0 ? void 0 : _f.blockNotes) !== null && _g !== void 0 ? _g : [],
+                        };
+                    }
+                }
+                else {
+                    if (!joinState.allFields.has(f.name.getName())) {
+                        item.logError('field-not-found', `\`${f.name.refString}\` not found`);
+                        continue;
+                    }
+                    const name = f.name.nameString;
+                    if (joinState.joinNames.has(name)) {
+                        const joinJoinState = getIncludeStateForJoin([...joinPath, name], state);
+                        if (item.kind === 'private') {
+                            // If we're making a join private, we need to make sure we didn't also make any
+                            // of its fields public or internal
+                            if (Object.values(joinJoinState.modifiers).some(m => m === 'public' || m === 'internal') ||
+                                joinJoinState.star === 'internal' ||
+                                joinJoinState.star === 'public') {
+                                f.logError('cannot-expand-access', `Cannot make \`${name}\` and also make fields in \`${name}\` public or internal`);
+                                continue;
+                            }
+                        }
+                    }
+                    if (joinState.alreadyPrivateFields.has(name)) {
+                        f.logError('cannot-expand-access', `Cannot expand access of \`${name}\` from private to ${item.kind}`);
+                    }
+                    if (joinState.modifiers.has(name)) {
+                        f.logError('duplicate-include', `Field \`${name}\` already referenced in include list`);
+                    }
+                    else {
+                        if (item.kind !== undefined) {
+                            joinState.modifiers.set((_h = f.as) !== null && _h !== void 0 ? _h : name, item.kind);
+                        }
+                        joinState.fieldsIncluded.add(name);
+                        if (f.note || item.note) {
+                            joinState.notes.set(name, {
+                                notes: (_k = (_j = f.note) === null || _j === void 0 ? void 0 : _j.notes) !== null && _k !== void 0 ? _k : [],
+                                blockNotes: (_m = (_l = item.note) === null || _l === void 0 ? void 0 : _l.blockNotes) !== null && _m !== void 0 ? _m : [],
+                            });
+                        }
+                    }
+                    if (f.as) {
+                        if (f.name instanceof field_references_1.WildcardFieldReference) {
+                            f.logError('wildcard-include-rename', 'Cannot rename a wildcard field in an `include` block');
+                        }
+                        else {
+                            if (joinPath.length > 0) {
+                                f.logError('cannot-rename-join-field', 'Cannot rename a joined field in an `include` block');
+                            }
+                            joinState.renames.push({
+                                name: f.name,
+                                as: f.as,
+                                location: f.location,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        else if (item instanceof include_item_1.IncludeExceptItem) {
+            for (const f of item.fields) {
+                const joinPath = f instanceof field_references_1.WildcardFieldReference
+                    ? (_p = (_o = f.joinPath) === null || _o === void 0 ? void 0 : _o.path) !== null && _p !== void 0 ? _p : []
+                    : f.path.slice(0, -1);
+                const joinState = getOrCreateIncludeStateForJoin(joinPath, state, from, f);
+                checkParents(state, joinPath, from, f, item.kind);
+                if (f instanceof field_references_1.WildcardFieldReference) {
+                    if (joinState.star !== undefined) {
+                        item.logError('already-used-star-in-include', 'Wildcard already used in this include block');
+                    }
+                    else {
+                        joinState.star = 'except';
+                    }
+                }
+                else {
+                    const name = f.getName();
+                    if (!joinState.allFields.has(name)) {
+                        item.logError('field-not-found', `\`${f.refString}\` not found`);
+                        continue;
+                    }
+                    if (joinState.joinNames.has(name)) {
+                        const joinJoinState = getIncludeStateForJoin([...joinPath, name], state);
+                        const star = joinJoinState.star;
+                        if (joinJoinState.fieldsIncluded.size > 0 ||
+                            star === 'inherit' ||
+                            star === 'public' ||
+                            star === 'private' ||
+                            star === 'internal') {
+                            f.logError('exclude-after-include', `Cannot except \`${name}\` when fields from \`${name}\` are already included`);
+                            continue;
+                        }
+                        else if (joinJoinState.fieldsExcepted.size > 0 ||
+                            star === 'except') {
+                            f.logError('exclude-after-exclude', `Cannot except \`${name}\` when fields from \`${name}\` are already excepted`);
+                            continue;
+                        }
+                    }
+                    if (joinState.star === 'except') {
+                        item.logWarning('except-star-and-list', 'Excluding specific fields is unnecessary if also using `except: *`');
+                    }
+                    else {
+                        joinState.fieldsExcepted.add(f.nameString);
+                    }
+                }
+            }
+        }
+    }
+    for (const join of state.joins) {
+        const joinState = join.state;
+        const starFields = new Set(joinState.allFields);
+        joinState.fieldsIncluded.forEach(f => starFields.delete(f));
+        joinState.fieldsExcepted.forEach(f => starFields.delete(f));
+        joinState.alreadyPrivateFields.forEach(f => starFields.delete(f));
+        if (joinState.star === 'except') {
+            joinState.fieldsToInclude = joinState.fieldsIncluded;
+        }
+        else {
+            joinState.fieldsToInclude = new Set(joinState.allFields);
+            for (const field of joinState.fieldsExcepted) {
+                joinState.fieldsToInclude.delete(field);
+            }
+            for (const field of starFields) {
+                if (joinState.star !== 'inherit') {
+                    joinState.modifiers.set(field, (_q = joinState.star) !== null && _q !== void 0 ? _q : 'private');
+                }
+                if (joinState.starNote) {
+                    joinState.notes.set(field, { ...joinState.starNote });
+                }
+            }
+        }
+    }
+    // TODO: validate that a field isn't renamed more than once
+    // TODO: validate that excluded fields are not referenced by included fields
+    // TODO: make renames fields work in existing references
+    // TODO: make renames that would replace an excluded field don't do that
+    return state;
+}
+exports.processIncludeList = processIncludeList;
+//# sourceMappingURL=include-utils.js.map

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

@@ -1,5 +1,5 @@
 import type { Dialect } from '../../../dialect';
-import type { StructDef } from '../../../model';
+import type { AccessModifierLabel, StructDef } from '../../../model';
 import type { HasParameter } from '../parameters/has-parameter';
 import type { FieldName, FieldSpace, QueryFieldSpace } from '../types/field-space';
 import type { LookupResult } from '../types/lookup-result';
@@ -16,5 +16,5 @@ export declare class ParameterSpace implements FieldSpace {
     dialectName(): string;
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
-    isProtectedAccessSpace(): boolean;
+    accessProtectionLevel(): AccessModifierLabel;
 }

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

@@ -76,8 +76,8 @@ class ParameterSpace {
     isQueryFieldSpace() {
         return false;
     }
-    isProtectedAccessSpace() {
-        return false;
+    accessProtectionLevel() {
+        return 'private';
     }
 }
 exports.ParameterSpace = ParameterSpace;

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

@@ -5,7 +5,7 @@
  * expressions in the query is called the "input space". There is a
  * specialized QuerySpace for each type of query operation.
  */
-import type { SourceDef } from '../../../model';
+import type { AccessModifierLabel, SourceDef } from '../../../model';
 import type { AtomicFieldDeclaration } from '../query-items/field-declaration';
 import { Join } from '../source-properties/join';
 import type { QueryFieldSpace } from '../types/field-space';
@@ -13,7 +13,7 @@ import type { QueryOperationSpace } from './query-spaces';
 import { RefinedSpace } from './refined-space';
 export declare class QueryInputSpace extends RefinedSpace implements QueryFieldSpace {
     private queryOutput;
-    readonly _isProtectedAccessSpace: boolean;
+    readonly _accessProtectionLevel: AccessModifierLabel;
     extendList: string[];
     /**
      * Because of circularity concerns this constructor is not typed
@@ -21,10 +21,10 @@ export declare class QueryInputSpace extends RefinedSpace implements QueryFieldS
      * @param input The source which might be extended
      * @param queryOutput MUST BE A QuerySpace
      */
-    constructor(input: SourceDef, queryOutput: QueryOperationSpace, _isProtectedAccessSpace: boolean);
+    constructor(input: SourceDef, queryOutput: QueryOperationSpace, _accessProtectionLevel: AccessModifierLabel);
     extendSource(extendField: Join | AtomicFieldDeclaration): void;
     isQueryFieldSpace(): this is QueryFieldSpace;
     outputSpace(): QueryOperationSpace;
     inputSpace(): this;
-    isProtectedAccessSpace(): boolean;
+    accessProtectionLevel(): AccessModifierLabel;
 }

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

@@ -32,10 +32,10 @@ class QueryInputSpace extends refined_space_1.RefinedSpace {
      * @param input The source which might be extended
      * @param queryOutput MUST BE A QuerySpace
      */
-    constructor(input, queryOutput, _isProtectedAccessSpace) {
+    constructor(input, queryOutput, _accessProtectionLevel) {
         super(input);
         this.queryOutput = queryOutput;
-        this._isProtectedAccessSpace = _isProtectedAccessSpace;
+        this._accessProtectionLevel = _accessProtectionLevel;
         this.extendList = [];
     }
     extendSource(extendField) {
@@ -56,8 +56,8 @@ class QueryInputSpace extends refined_space_1.RefinedSpace {
     inputSpace() {
         return this;
     }
-    isProtectedAccessSpace() {
-        return this._isProtectedAccessSpace;
+    accessProtectionLevel() {
+        return this._accessProtectionLevel;
     }
 }
 exports.QueryInputSpace = QueryInputSpace;

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

@@ -41,6 +41,7 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     constructor(queryInputSpace: SourceFieldSpace, refineThis: model.PipeSegment | undefined, nestParent: QueryOperationSpace | undefined, astEl: MalloyElement);
     abstract addRefineFromFields(refineThis: model.PipeSegment): void;
     logError<T extends MessageCode>(code: T, parameters: MessageParameterType<T>, options?: Omit<LogMessageOptions, 'severity'>): T;
+    accessProtectionLevel(): model.AccessModifierLabel;
     inputSpace(): QueryInputSpace;
     outputSpace(): QueryOperationSpace;
     protected addWild(wild: WildcardFieldReference): void;

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

@@ -81,7 +81,7 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
         // (or `getPipeSegment` for index segments); if anyone
         // tries to access it before that, they'll get an error
         this._fieldUsage = undefined;
-        this.exprSpace = new query_input_space_1.QueryInputSpace(queryInputSpace.structDef(), this, queryInputSpace.isProtectedAccessSpace());
+        this.exprSpace = new query_input_space_1.QueryInputSpace(queryInputSpace.structDef(), this, queryInputSpace.accessProtectionLevel());
         if (refineThis)
             this.addRefineFromFields(refineThis);
     }
@@ -91,6 +91,9 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
         }
         return code;
     }
+    accessProtectionLevel() {
+        return 'public';
+    }
     inputSpace() {
         return this.exprSpace;
     }

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

@@ -1,23 +1,19 @@
-import type { AccessModifierLabel, Annotation, DocumentLocation, SourceDef } from '../../../model/malloy_types';
+import { type AccessModifierLabel, type Annotation, type SourceDef } from '../../../model/malloy_types';
 import type { FieldListEdit } from '../source-properties/field-list-edit';
 import { DynamicSpace } from './dynamic-space';
 import type { MalloyElement } from '../types/malloy-element';
 import type { ParameterSpace } from './parameter-space';
-import type { FieldReference } from '../query-items/field-references';
+import { type IncludeProcessingState } from './include-utils';
 export declare class RefinedSpace extends DynamicSpace {
     /**
      * Factory for FieldSpace when there are accept/except edits
      * @param from A structdef which seeds this space
      * @param choose A accept/except edit of the "from" fields
      */
-    static filteredFrom(from: SourceDef, choose: FieldListEdit | undefined, fieldsToInclude: Set<string> | undefined, renames: {
-        as: string;
-        name: FieldReference;
-        location: DocumentLocation;
-    }[] | undefined, parameters: ParameterSpace | undefined): RefinedSpace;
+    static filteredFrom(from: SourceDef, choose: FieldListEdit | undefined, includeState: IncludeProcessingState, parameters: ParameterSpace | undefined): RefinedSpace;
     pushFields(...defs: MalloyElement[]): void;
     addField(def: MalloyElement): void;
     addAccessModifiers(ams: Map<string, AccessModifierLabel>): void;
     addNotes(notes: Map<string, Annotation>): void;
-    isProtectedAccessSpace(): boolean;
+    accessProtectionLevel(): AccessModifierLabel;
 }

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

@@ -23,20 +23,27 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RefinedSpace = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
 const dynamic_space_1 = require("./dynamic-space");
 const space_entry_1 = require("../types/space-entry");
 const rename_space_field_1 = require("./rename-space-field");
 const space_field_1 = require("../types/space-field");
+const include_utils_1 = require("./include-utils");
 class RefinedSpace extends dynamic_space_1.DynamicSpace {
     /**
      * Factory for FieldSpace when there are accept/except edits
      * @param from A structdef which seeds this space
      * @param choose A accept/except edit of the "from" fields
      */
-    static filteredFrom(from, choose, fieldsToInclude, renames, parameters) {
-        const edited = new RefinedSpace(from);
+    static filteredFrom(from, choose, includeState, parameters) {
+        var _a;
+        const edited = new RefinedSpace({
+            ...from,
+            fields: editJoinsFromIncludeState([], from, includeState),
+        });
         const renameMap = new Map();
-        for (const rename of renames !== null && renames !== void 0 ? renames : []) {
+        const s = (0, include_utils_1.getIncludeStateForJoin)([], includeState);
+        for (const rename of (_a = s.renames) !== null && _a !== void 0 ? _a : []) {
             if (renameMap.has(rename.name.refString)) {
                 rename.name.logError('already-renamed', `${rename.name.refString} already renamed to ${rename.as}`);
             }
@@ -48,11 +55,11 @@ class RefinedSpace extends dynamic_space_1.DynamicSpace {
                 });
             }
         }
-        if (fieldsToInclude !== undefined) {
+        if (s.fieldsToInclude !== undefined) {
             const oldMap = edited.entries();
             edited.dropEntries();
             for (const [symbol, value] of oldMap) {
-                if (fieldsToInclude.has(symbol)) {
+                if (s.fieldsToInclude.has(symbol)) {
                     const renamed = renameMap.get(symbol);
                     if (renamed) {
                         if (value instanceof space_field_1.SpaceField) {
@@ -119,9 +126,59 @@ class RefinedSpace extends dynamic_space_1.DynamicSpace {
             this.newNotes.set(symbol, note);
         }
     }
-    isProtectedAccessSpace() {
-        return true;
+    accessProtectionLevel() {
+        return 'internal';
     }
 }
 exports.RefinedSpace = RefinedSpace;
+function editJoinsFromIncludeState(path, from, includeState) {
+    var _a, _b, _c;
+    let fields;
+    const joinedState = (0, include_utils_1.getIncludeStateForJoin)(path, includeState);
+    const isJoin = path.length > 0;
+    if (isJoin) {
+        if (joinedState.fieldsToInclude) {
+            fields = from.fields.filter(f => { var _a, _b; return (_a = joinedState.fieldsToInclude) === null || _a === void 0 ? void 0 : _a.has((_b = f.as) !== null && _b !== void 0 ? _b : f.name); });
+        }
+        else {
+            fields = from.fields;
+        }
+    }
+    else {
+        fields = from.fields;
+    }
+    // const fields = from.fields;
+    const updatedFields = [];
+    for (const field of fields) {
+        const name = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+        // TODO ensure you can't make it more permissive here...
+        const accessModifier = (_b = joinedState.modifiers.get(name)) !== null && _b !== void 0 ? _b : field.accessModifier;
+        const notes = joinedState.notes.get(name);
+        const rename = joinedState.renames.find(r => { var _a; return r.name.nameString === ((_a = field.as) !== null && _a !== void 0 ? _a : field.name); });
+        const editedField = isJoin
+            ? {
+                ...field,
+                as: rename ? rename.name.nameString : field.as,
+                accessModifier: accessModifier === 'public' ? undefined : accessModifier,
+                annotation: notes
+                    ? {
+                        inherits: field.annotation,
+                        blockNotes: notes.blockNotes,
+                        notes: notes.notes,
+                    }
+                    : field.annotation,
+            }
+            : { ...field };
+        if ((0, malloy_types_1.isJoined)(editedField)) {
+            updatedFields.push({
+                ...editedField,
+                fields: editJoinsFromIncludeState([...path, (_c = field.as) !== null && _c !== void 0 ? _c : field.name], editedField, includeState),
+            });
+        }
+        else {
+            updatedFields.push(editedField);
+        }
+    }
+    return updatedFields;
+}
 //# sourceMappingURL=refined-space.js.map