@malloydata/malloy 0.0.222-dev241212204326 → 0.0.222

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

@@ -15,6 +15,7 @@ export declare class ConstantFieldSpace implements FieldSpace {
     dialectName(): string;
     dialectObj(): undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
+    isProtectedAccessSpace(): boolean;
 }
 export declare class ConstantExpression extends ExpressionDef {
     readonly expr: ExpressionDef;

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

@@ -58,6 +58,9 @@ class ConstantFieldSpace {
     isQueryFieldSpace() {
         return false;
     }
+    isProtectedAccessSpace() {
+        return false;
+    }
 }
 exports.ConstantFieldSpace = ConstantFieldSpace;
 class ConstantExpression extends expression_def_1.ExpressionDef {

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

@@ -12,6 +12,8 @@ export declare abstract class DynamicSpace extends StaticSpace implements Source
     private complete;
     private parameters;
     protected newTimezone?: string;
+    protected newAccessModifiers: Map<string, model.AccessModifierLabel>;
+    protected newNotes: Map<string, model.Annotation>;
     constructor(extending: SourceDef);
     protected setEntry(name: string, value: SpaceEntry): void;
     addParameters(parameters: HasParameter[]): DynamicSpace;

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

@@ -61,6 +61,8 @@ class DynamicSpace extends static_space_1.StaticSpace {
         super(structuredClone(extending), extending.dialect);
         this.complete = false;
         this.parameters = [];
+        this.newAccessModifiers = new Map();
+        this.newNotes = new Map();
         this.fromSource = extending;
         this.sourceDef = undefined;
     }
@@ -112,6 +114,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
             }
             this.sourceDef = { ...this.fromSource, fields: [] };
             this.sourceDef.parameters = parameters;
+            const fieldIndices = new Map();
             // Need to process the entities in specific order
             const fields = [];
             const joins = [];
@@ -130,10 +133,11 @@ class DynamicSpace extends static_space_1.StaticSpace {
             }
             const reorderFields = [...fields, ...joins, ...turtles];
             const parameterSpace = this.parameterSpace();
-            for (const [, field] of reorderFields) {
+            for (const [name, field] of reorderFields) {
                 if (field instanceof join_space_field_1.JoinSpaceField) {
                     const joinStruct = field.join.structDef(parameterSpace);
                     if (!error_factory_1.ErrorFactory.didCreate(joinStruct)) {
+                        fieldIndices.set(name, this.sourceDef.fields.length);
                         this.sourceDef.fields.push(joinStruct);
                         fixupJoins.push([field.join, joinStruct]);
                     }
@@ -141,6 +145,7 @@ class DynamicSpace extends static_space_1.StaticSpace {
                 else {
                     const fieldDef = field.fieldDef();
                     if (fieldDef) {
+                        fieldIndices.set(name, this.sourceDef.fields.length);
                         this.sourceDef.fields.push(fieldDef);
                     }
                     // TODO I'm just removing this, but perhaps instead I should just filter
@@ -154,6 +159,38 @@ class DynamicSpace extends static_space_1.StaticSpace {
             for (const [join, missingOn] of fixupJoins) {
                 join.fixupJoinOn(this, missingOn);
             }
+            // 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; });
+                if (index === -1) {
+                    throw new Error(`Can't find field '${name}' to set access modifier`);
+                }
+                if (access === 'public') {
+                    delete this.sourceDef.fields[index].accessModifier;
+                }
+                else {
+                    this.sourceDef.fields[index] = {
+                        ...this.sourceDef.fields[index],
+                        accessModifier: access,
+                    };
+                }
+            }
+            // TODO does this need to be done when the space is instantiated?
+            // e.g. if a field had a compiler flag on it...
+            for (const [name, note] of this.newNotes) {
+                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`);
+                }
+                const field = this.sourceDef.fields[index];
+                this.sourceDef.fields[index] = {
+                    ...field,
+                    annotation: {
+                        ...note,
+                        inherits: field.annotation,
+                    },
+                };
+            }
         }
         if (this.newTimezone && model.isSourceDef(this.sourceDef)) {
             this.sourceDef.queryTimezone = this.newTimezone;

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

@@ -16,4 +16,5 @@ export declare class ParameterSpace implements FieldSpace {
     dialectName(): string;
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
+    isProtectedAccessSpace(): boolean;
 }

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

@@ -76,6 +76,9 @@ class ParameterSpace {
     isQueryFieldSpace() {
         return false;
     }
+    isProtectedAccessSpace() {
+        return false;
+    }
 }
 exports.ParameterSpace = ParameterSpace;
 //# sourceMappingURL=parameter-space.js.map

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

@@ -13,6 +13,7 @@ import { QueryOperationSpace } from './query-spaces';
 import { RefinedSpace } from './refined-space';
 export declare class QueryInputSpace extends RefinedSpace implements QueryFieldSpace {
     private queryOutput;
+    readonly _isProtectedAccessSpace: boolean;
     extendList: string[];
     /**
      * Because of circularity concerns this constructor is not typed
@@ -20,9 +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);
+    constructor(input: SourceDef, queryOutput: QueryOperationSpace, _isProtectedAccessSpace: boolean);
     extendSource(extendField: Join | AtomicFieldDeclaration): void;
     isQueryFieldSpace(): this is QueryFieldSpace;
     outputSpace(): QueryOperationSpace;
     inputSpace(): this;
+    isProtectedAccessSpace(): boolean;
 }

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

@@ -32,9 +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) {
+    constructor(input, queryOutput, _isProtectedAccessSpace) {
         super(input);
         this.queryOutput = queryOutput;
+        this._isProtectedAccessSpace = _isProtectedAccessSpace;
         this.extendList = [];
     }
     extendSource(extendField) {
@@ -55,6 +56,9 @@ class QueryInputSpace extends refined_space_1.RefinedSpace {
     inputSpace() {
         return this;
     }
+    isProtectedAccessSpace() {
+        return this._isProtectedAccessSpace;
+    }
 }
 exports.QueryInputSpace = QueryInputSpace;
 //# sourceMappingURL=query-input-space.js.map

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._compositeFieldUsage = undefined;
-        this.exprSpace = new query_input_space_1.QueryInputSpace(queryInputSpace.structDef(), this);
+        this.exprSpace = new query_input_space_1.QueryInputSpace(queryInputSpace.structDef(), this, queryInputSpace.isProtectedAccessSpace());
         if (refineThis)
             this.addRefineFromFields(refineThis);
     }

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

@@ -1,15 +1,23 @@
-import { SourceDef } from '../../../model/malloy_types';
+import { AccessModifierLabel, Annotation, DocumentLocation, SourceDef } from '../../../model/malloy_types';
 import { FieldListEdit } from '../source-properties/field-list-edit';
 import { DynamicSpace } from './dynamic-space';
 import { MalloyElement } from '../types/malloy-element';
 import { ParameterSpace } from './parameter-space';
+import { FieldReference } from '../query-items/field-references';
 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, parameters: ParameterSpace | undefined): RefinedSpace;
+    static filteredFrom(from: SourceDef, choose: FieldListEdit | undefined, fieldsToInclude: Set<string> | undefined, renames: {
+        as: string;
+        name: FieldReference;
+        location: DocumentLocation;
+    }[] | undefined, 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;
 }

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

@@ -25,15 +25,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RefinedSpace = void 0;
 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");
 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, parameters) {
+    static filteredFrom(from, choose, fieldsToInclude, renames, parameters) {
         const edited = new RefinedSpace(from);
-        if (choose) {
+        const renameMap = new Map();
+        for (const rename of renames !== null && renames !== void 0 ? renames : []) {
+            if (renameMap.has(rename.name.refString)) {
+                rename.name.logError('already-renamed', `${rename.name.refString} already renamed to ${rename.as}`);
+            }
+            else {
+                renameMap.set(rename.name.refString, {
+                    as: rename.as,
+                    location: rename.location,
+                    logTo: rename.name,
+                });
+            }
+        }
+        if (fieldsToInclude !== undefined) {
+            const oldMap = edited.entries();
+            edited.dropEntries();
+            for (const [symbol, value] of oldMap) {
+                if (fieldsToInclude.has(symbol)) {
+                    const renamed = renameMap.get(symbol);
+                    if (renamed) {
+                        if (value instanceof space_field_1.SpaceField) {
+                            edited.setEntry(renamed.as, new rename_space_field_1.RenameSpaceField(value, renamed.as, renamed.location));
+                        }
+                        else {
+                            renamed.logTo.logError('cannot-rename-non-field', `Cannot rename \`${symbol}\` which is not a field`);
+                        }
+                    }
+                    else {
+                        edited.setEntry(symbol, value);
+                    }
+                }
+            }
+            if (choose !== undefined) {
+                choose.logError('accept-except-not-compatible-with-include', "Can't use `accept:` or `except:` with `include`");
+            }
+        }
+        else if (choose) {
             const names = choose.refs.list;
             const oldMap = edited.entries();
             for (const name of names) {
@@ -71,6 +109,19 @@ class RefinedSpace extends dynamic_space_1.DynamicSpace {
             def.logError('unexpected-element-type', `Internal error, ${def.elementType} not expected in this context`);
         }
     }
+    addAccessModifiers(ams) {
+        for (const [symbol, am] of ams) {
+            this.newAccessModifiers.set(symbol, am);
+        }
+    }
+    addNotes(notes) {
+        for (const [symbol, note] of notes) {
+            this.newNotes.set(symbol, note);
+        }
+    }
+    isProtectedAccessSpace() {
+        return true;
+    }
 }
 exports.RefinedSpace = RefinedSpace;
 //# sourceMappingURL=refined-space.js.map

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

@@ -15,6 +15,7 @@ export declare class StaticSpace implements FieldSpace {
     dialectObj(): Dialect | undefined;
     defToSpaceField(from: FieldDef): SpaceField;
     private get map();
+    isProtectedAccessSpace(): boolean;
     protected dropEntries(): void;
     protected dropEntry(name: string): void;
     entry(name: string): SpaceEntry | undefined;

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

@@ -75,6 +75,9 @@ class StaticSpace {
         }
         return this.memoMap;
     }
+    isProtectedAccessSpace() {
+        return false;
+    }
     dropEntries() {
         this.memoMap = {};
     }
@@ -138,6 +141,20 @@ class StaticSpace {
                     text: head.refString,
                 });
             }
+            if (definition === null || definition === void 0 ? void 0 : definition.accessModifier) {
+                // TODO path.length === 1 will not work with namespaces
+                if (!(this.isProtectedAccessSpace() &&
+                    definition.accessModifier === 'internal' &&
+                    path.length === 1)) {
+                    return {
+                        error: {
+                            message: `'${head}' is ${definition === null || definition === void 0 ? void 0 : definition.accessModifier}`,
+                            code: 'field-not-accessible',
+                        },
+                        found: undefined,
+                    };
+                }
+            }
         } // cswenson review todo { else this is SpaceEntry not a field which can only be a param and what is going on? }
         const joinPath = found instanceof struct_space_field_base_1.StructSpaceFieldBase
             ? [{ ...found.joinPathElement, name: head.refString }]

package/dist/lang/ast/index.d.ts

@@ -10,6 +10,7 @@ export * from './source-query-elements/sq-source';
 export * from './source-query-elements/sq-reference';
 export * from './source-query-elements/sq-extend';
 export * from './source-query-elements/sq-compose';
+export * from './source-query-elements/include-item';
 export * from './source-properties/field-list-edit';
 export * from './source-properties/primary-key';
 export * from './source-properties/renames';

package/dist/lang/ast/index.js

@@ -48,6 +48,7 @@ __exportStar(require("./source-query-elements/sq-source"), exports);
 __exportStar(require("./source-query-elements/sq-reference"), exports);
 __exportStar(require("./source-query-elements/sq-extend"), exports);
 __exportStar(require("./source-query-elements/sq-compose"), exports);
+__exportStar(require("./source-query-elements/include-item"), exports);
 __exportStar(require("./source-properties/field-list-edit"), exports);
 __exportStar(require("./source-properties/primary-key"), exports);
 __exportStar(require("./source-properties/renames"), exports);

package/dist/lang/ast/query-items/field-declaration.d.ts

@@ -18,6 +18,7 @@ export declare abstract class AtomicFieldDeclaration extends MalloyElement imple
     extendNote: typeof extendNoteMethod;
     note?: Annotation;
     constructor(expr: ExpressionDef, defineName: string, exprSrc?: string | undefined);
+    getName(): string;
     fieldDef(fs: FieldSpace, exprName: string): FieldDef;
     abstract typecheckExprValue(expr: ExprValue): void;
     executesInOutputSpace(): boolean;
@@ -72,6 +73,7 @@ export declare class DefSpace implements FieldSpace {
     isQueryFieldSpace(): this is QueryFieldSpace;
     outputSpace(): import("../field-space/query-spaces").QueryOperationSpace;
     inputSpace(): import("../types/field-space").SourceFieldSpace;
+    isProtectedAccessSpace(): boolean;
 }
 export declare class FieldDefinitionValue extends SpaceField {
     readonly space: FieldSpace;

package/dist/lang/ast/query-items/field-declaration.js

@@ -62,6 +62,9 @@ class AtomicFieldDeclaration extends malloy_element_1.MalloyElement {
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
     }
+    getName() {
+        return this.defineName;
+    }
     fieldDef(fs, exprName) {
         /*
          * In an explore we cannot reference the thing we are defining, you need
@@ -274,6 +277,9 @@ class DefSpace {
         }
         throw new Error('Not a query field space');
     }
+    isProtectedAccessSpace() {
+        return true;
+    }
 }
 exports.DefSpace = DefSpace;
 class FieldDefinitionValue extends space_field_1.SpaceField {

package/dist/lang/ast/query-items/field-references.d.ts

@@ -13,6 +13,7 @@ export declare abstract class FieldReference extends ListOf<FieldName> implement
     extendNote: typeof extendNoteMethod;
     constructor(names: FieldName[]);
     makeEntry(fs: DynamicSpace): void;
+    getName(): string;
     get refToField(): RefToField;
     get refString(): string;
     get path(): string[];
@@ -26,6 +27,10 @@ export declare class AcceptExceptFieldReference extends FieldReference {
     elementType: string;
     typecheck(): void;
 }
+export declare class AccessModifierFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(): void;
+}
 export declare class ExpressionFieldReference extends FieldReference {
     elementType: string;
     typecheck(): void;

package/dist/lang/ast/query-items/field-references.js

@@ -22,7 +22,7 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FieldReferences = exports.WildcardFieldReference = exports.ViewOrScalarFieldReference = exports.DimensionFieldReference = exports.MeasureFieldReference = exports.DeclareFieldReference = exports.ProjectFieldReference = exports.GroupByFieldReference = exports.AggregateFieldReference = exports.IndexFieldReference = exports.CalculateFieldReference = exports.ParameterFieldReference = exports.PartitionByFieldReference = exports.ExpressionFieldReference = exports.AcceptExceptFieldReference = exports.FieldReference = void 0;
+exports.FieldReferences = exports.WildcardFieldReference = exports.ViewOrScalarFieldReference = exports.DimensionFieldReference = exports.MeasureFieldReference = exports.DeclareFieldReference = exports.ProjectFieldReference = exports.GroupByFieldReference = exports.AggregateFieldReference = exports.IndexFieldReference = exports.CalculateFieldReference = exports.ParameterFieldReference = exports.PartitionByFieldReference = exports.ExpressionFieldReference = exports.AccessModifierFieldReference = exports.AcceptExceptFieldReference = exports.FieldReference = void 0;
 const reference_field_1 = require("../field-space/reference-field");
 const definition_list_1 = require("../types/definition-list");
 const malloy_element_1 = require("../types/malloy-element");
@@ -45,6 +45,9 @@ class FieldReference extends malloy_element_1.ListOf {
             fs.newEntry(refName, this, new reference_field_1.ReferenceField(this, fromFS));
         }
     }
+    getName() {
+        return this.nameString;
+    }
     get refToField() {
         return {
             type: 'fieldref',
@@ -94,6 +97,17 @@ class AcceptExceptFieldReference extends FieldReference {
     }
 }
 exports.AcceptExceptFieldReference = AcceptExceptFieldReference;
+class AccessModifierFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'accessModifierFieldReference';
+    }
+    // Nothing to typecheck here
+    typecheck() {
+        return;
+    }
+}
+exports.AccessModifierFieldReference = AccessModifierFieldReference;
 class ExpressionFieldReference extends FieldReference {
     constructor() {
         super(...arguments);
@@ -230,7 +244,7 @@ class WildcardFieldReference extends malloy_element_1.MalloyElement {
         this.isNoteableObj = true;
         this.extendNote = noteable_1.extendNoteMethod;
         this.except = new Set();
-        this.has({ joinPath: joinPath });
+        this.has({ joinPath });
     }
     getFieldDef() {
         throw this.internalError('fielddef request from wildcard reference');

package/dist/lang/ast/query-properties/declare-fields.d.ts

@@ -1,11 +1,14 @@
+import { AccessModifierLabel } from '../../../model';
 import { AtomicFieldDeclaration } from '../query-items/field-declaration';
 import { DefinitionList } from '../types/definition-list';
 import { QueryBuilder } from '../types/query-builder';
 import { LegalRefinementStage, QueryPropertyInterface } from '../types/query-property-interface';
 export declare class DeclareFields extends DefinitionList<AtomicFieldDeclaration> implements QueryPropertyInterface {
+    readonly accessModifier: AccessModifierLabel | undefined;
     elementType: string;
     queryRefinementStage: LegalRefinementStage;
     forceQueryClass: undefined;
-    constructor(fields: AtomicFieldDeclaration[]);
+    constructor(fields: AtomicFieldDeclaration[], accessModifier: AccessModifierLabel | undefined);
     queryExecute(executeFor: QueryBuilder): void;
+    get delarationNames(): string[];
 }

package/dist/lang/ast/query-properties/declare-fields.js

@@ -26,8 +26,9 @@ exports.DeclareFields = void 0;
 const definition_list_1 = require("../types/definition-list");
 const query_property_interface_1 = require("../types/query-property-interface");
 class DeclareFields extends definition_list_1.DefinitionList {
-    constructor(fields) {
+    constructor(fields, accessModifier) {
         super(fields);
+        this.accessModifier = accessModifier;
         this.elementType = 'declareFields';
         this.queryRefinementStage = query_property_interface_1.LegalRefinementStage.Single;
         this.forceQueryClass = undefined;
@@ -37,6 +38,9 @@ class DeclareFields extends definition_list_1.DefinitionList {
             executeFor.inputFS.extendSource(qel);
         }
     }
+    get delarationNames() {
+        return this.list.map(el => el.defineName);
+    }
 }
 exports.DeclareFields = DeclareFields;
 //# sourceMappingURL=declare-fields.js.map

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

@@ -28,7 +28,7 @@ class CompositeSource extends source_1.Source {
         const dialect = sourceDefs[0].dialect;
         const name = 'composite_source';
         const fields = [];
-        const fieldNames = new Set();
+        const fieldsByName = new Map();
         this.sources.forEach((source, index) => {
             var _a;
             const sourceDef = sourceDefs[index];
@@ -42,9 +42,12 @@ class CompositeSource extends source_1.Source {
                     source.logWarning('composite-source-atomic-fields-only', `Only atomic fields are supported in composite sources; field \`${field.name}\` is not atomic and will be ignored`);
                     continue;
                 }
+                if (field.accessModifier === 'private') {
+                    continue;
+                }
                 const fieldName = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
-                if (!fieldNames.has(fieldName)) {
-                    fieldNames.add(fieldName);
+                const existing = fieldsByName.get(fieldName);
+                if (existing === undefined) {
                     const compositeField = {
                         ...field,
                         name: fieldName,
@@ -54,8 +57,12 @@ class CompositeSource extends source_1.Source {
                         code: this.code,
                         location: this.codeLocation,
                     };
+                    fieldsByName.set(fieldName, compositeField);
                     fields.push(compositeField);
                 }
+                else if (field.accessModifier === 'internal') {
+                    existing.accessModifier = 'internal';
+                }
             }
         });
         return {

package/dist/lang/ast/source-elements/refined-source.d.ts

@@ -3,15 +3,17 @@ import { HasParameter } from '../parameters/has-parameter';
 import { SourceDesc } from '../types/source-desc';
 import { Source } from './source';
 import { ParameterSpace } from '../field-space/parameter-space';
+import { IncludeItem } from '../source-query-elements/include-item';
 /**
  * A Source made from a source reference and a set of refinements
  */
 export declare class RefinedSource extends Source {
     readonly source: Source;
     readonly refinement: SourceDesc;
+    readonly includeList: IncludeItem[] | undefined;
     elementType: string;
     currentAnnotation?: Annotation;
-    constructor(source: Source, refinement: SourceDesc);
+    constructor(source: Source, refinement: SourceDesc, includeList: IncludeItem[] | undefined);
     getSourceDef(parameterSpace: ParameterSpace | undefined): SourceDef;
     withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): SourceDef;
 }