@malloydata/malloy 0.0.157 → 0.0.158-dev240805161224

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

@@ -46,18 +46,18 @@ class QueryArrow extends query_base_1.QueryBase {
         if (this.source instanceof source_1.Source) {
             // We create a fresh query with either the QOPDesc as the head,
             // the view as the head, or the scalar as the head (if scalar lenses is enabled)
-            const structRef = isRefOk
-                ? this.source.structRef()
-                : this.source.structDef();
+            const invoked = isRefOk
+                ? this.source.structRef(undefined)
+                : { structRef: this.source.structDef(undefined) };
             queryBase = {
                 type: 'query',
-                structRef,
+                ...invoked,
                 pipeline: [],
                 location: this.location,
             };
-            inputStruct = (0, malloy_types_1.refIsStructDef)(structRef)
-                ? structRef
-                : this.source.structDef();
+            inputStruct = (0, malloy_types_1.refIsStructDef)(invoked.structRef)
+                ? invoked.structRef
+                : this.source.structDef(undefined);
             fieldSpace = new static_space_1.StaticSpace(inputStruct);
         }
         else {

package/dist/lang/ast/query-elements/query-head-struct.d.ts

@@ -1,9 +1,11 @@
-import { StructDef, StructRef } from '../../../model/malloy_types';
+import { Argument, InvokedStructRef, StructDef, StructRef } from '../../../model/malloy_types';
 import { Source } from '../source-elements/source';
+import { ParameterSpace } from '../field-space/parameter-space';
 export declare class QueryHeadStruct extends Source {
     readonly fromRef: StructRef;
+    readonly sourceArguments: Record<string, Argument> | undefined;
     elementType: string;
-    constructor(fromRef: StructRef);
-    structRef(): StructRef;
-    structDef(): StructDef;
+    constructor(fromRef: StructRef, sourceArguments: Record<string, Argument> | undefined);
+    structRef(): InvokedStructRef;
+    structDef(parameterSpace: ParameterSpace | undefined): StructDef;
 }

package/dist/lang/ast/query-elements/query-head-struct.js

@@ -27,21 +27,22 @@ const malloy_types_1 = require("../../../model/malloy_types");
 const source_1 = require("../source-elements/source");
 const named_source_1 = require("../source-elements/named-source");
 class QueryHeadStruct extends source_1.Source {
-    constructor(fromRef) {
+    constructor(fromRef, sourceArguments) {
         super();
         this.fromRef = fromRef;
+        this.sourceArguments = sourceArguments;
         this.elementType = 'internalOnlyQueryHead';
     }
     structRef() {
-        return this.fromRef;
+        return { structRef: this.fromRef };
     }
-    structDef() {
+    structDef(parameterSpace) {
         if ((0, malloy_types_1.refIsStructDef)(this.fromRef)) {
             return this.fromRef;
         }
-        const ns = new named_source_1.NamedSource(this.fromRef);
+        const ns = new named_source_1.NamedSource(this.fromRef, this.sourceArguments, undefined);
         this.has({ exploreReference: ns });
-        return ns.structDef();
+        return ns.structDef(parameterSpace);
     }
 }
 exports.QueryHeadStruct = QueryHeadStruct;

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

@@ -40,16 +40,16 @@ class QueryRaw extends malloy_element_1.MalloyElement {
         this.elementType = 'query-raw';
     }
     queryComp(isRefOk) {
-        const structRef = isRefOk
-            ? this.source.structRef()
-            : this.source.structDef();
-        const structDef = (0, malloy_types_1.refIsStructDef)(structRef)
-            ? structRef
-            : this.source.structDef();
+        const invoked = isRefOk
+            ? this.source.structRef(undefined)
+            : { structRef: this.source.structDef(undefined) };
+        const structDef = (0, malloy_types_1.refIsStructDef)(invoked.structRef)
+            ? invoked.structRef
+            : this.source.structDef(undefined);
         return {
             query: {
                 type: 'query',
-                structRef,
+                ...invoked,
                 pipeline: [{ type: 'raw', fields: [] }],
                 location: this.location,
             },

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

@@ -54,9 +54,9 @@ class QueryReference extends malloy_element_1.MalloyElement {
             return oops();
         }
         if (query.type === 'query') {
-            const queryHead = new query_head_struct_1.QueryHeadStruct(query.structRef);
+            const queryHead = new query_head_struct_1.QueryHeadStruct(query.structRef, query.sourceArguments);
             this.has({ queryHead: queryHead });
-            const inputStruct = queryHead.structDef();
+            const inputStruct = queryHead.structDef(undefined);
             const outputStruct = (0, struct_utils_1.getFinalStruct)(this, inputStruct, query.pipeline);
             const unRefedQuery = isRefOk
                 ? query

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

@@ -34,6 +34,10 @@ export declare class PartitionByFieldReference extends FieldReference {
     elementType: string;
     typecheck(): void;
 }
+export declare class ParameterFieldReference extends FieldReference {
+    elementType: string;
+    typecheck(): void;
+}
 export declare class CalculateFieldReference extends FieldReference {
     elementType: string;
     typecheck(type: TypeDesc): 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.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.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");
@@ -116,6 +116,17 @@ class PartitionByFieldReference extends FieldReference {
     }
 }
 exports.PartitionByFieldReference = PartitionByFieldReference;
+class ParameterFieldReference extends FieldReference {
+    constructor() {
+        super(...arguments);
+        this.elementType = 'parameterFieldReference';
+    }
+    // The invocation of the argument will typecheck this
+    typecheck() {
+        return;
+    }
+}
+exports.ParameterFieldReference = ParameterFieldReference;
 class CalculateFieldReference extends FieldReference {
     constructor() {
         super(...arguments);

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

@@ -1,19 +1,22 @@
-import { StructDef, StructRef } from '../../../model/malloy_types';
+import { Argument, InvokedStructRef, StructDef } from '../../../model/malloy_types';
 import { Source } from './source';
-import { ConstantSubExpression } from '../expressions/constant-sub-expression';
-import { MalloyElement, ModelEntryReference } from '../types/malloy-element';
-export declare class IsValueBlock extends MalloyElement {
-    readonly isMap: Record<string, ConstantSubExpression>;
-    elementType: string;
-    constructor(isMap: Record<string, ConstantSubExpression>);
-}
+import { ModelEntryReference } from '../types/malloy-element';
+import { Argument as HasArgument } from '../parameters/argument';
+import { LogSeverity } from '../../parse-log';
+import { ParameterSpace } from '../field-space/parameter-space';
+import { HasParameter } from '../parameters/has-parameter';
 export declare class NamedSource extends Source {
     readonly ref: ModelEntryReference | string;
+    readonly sourceArguments: Record<string, Argument> | undefined;
+    readonly args: HasArgument[] | undefined;
     elementType: string;
-    protected isBlock?: IsValueBlock;
-    constructor(ref: ModelEntryReference | string, paramValues?: Record<string, ConstantSubExpression>);
+    constructor(ref: ModelEntryReference | string, sourceArguments: Record<string, Argument> | undefined, args: HasArgument[] | undefined);
     get refName(): string;
-    structRef(): StructRef;
+    structRef(parameterSpace: ParameterSpace | undefined): InvokedStructRef;
+    refLog(message: string, severity?: LogSeverity): void;
     modelStruct(): StructDef | undefined;
-    structDef(): StructDef;
+    private evaluateArgumentsForRef;
+    private evaluateArguments;
+    structDef(parameterSpace: ParameterSpace | undefined): StructDef;
+    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): StructDef;
 }

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

@@ -1,6 +1,7 @@
 "use strict";
 /*
  * Copyright 2023 Google LLC
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
@@ -22,29 +23,23 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NamedSource = exports.IsValueBlock = void 0;
+exports.NamedSource = void 0;
 const malloy_types_1 = require("../../../model/malloy_types");
 const source_1 = require("./source");
 const error_factory_1 = require("../error-factory");
 const time_utils_1 = require("../time-utils");
 const malloy_element_1 = require("../types/malloy-element");
-class IsValueBlock extends malloy_element_1.MalloyElement {
-    constructor(isMap) {
-        super();
-        this.isMap = isMap;
-        this.elementType = 'isValueBlock';
-        this.has(isMap);
-    }
-}
-exports.IsValueBlock = IsValueBlock;
+const expr_id_reference_1 = require("../expressions/expr-id-reference");
+const parameter_space_1 = require("../field-space/parameter-space");
 class NamedSource extends source_1.Source {
-    constructor(ref, paramValues = {}) {
+    constructor(ref, sourceArguments, args) {
         super();
         this.ref = ref;
+        this.sourceArguments = sourceArguments;
+        this.args = args;
         this.elementType = 'namedSource';
-        if (paramValues && Object.keys(paramValues).length > 0) {
-            this.isBlock = new IsValueBlock(paramValues);
-            this.has({ parameterValues: this.isBlock });
+        if (args) {
+            this.has({ args });
         }
         if (ref instanceof malloy_element_1.ModelEntryReference) {
             this.has({ ref: ref });
@@ -53,17 +48,26 @@ class NamedSource extends source_1.Source {
     get refName() {
         return this.ref instanceof malloy_element_1.ModelEntryReference ? this.ref.name : this.ref;
     }
-    structRef() {
-        if (this.isBlock) {
-            return this.structDef();
-        }
+    structRef(parameterSpace) {
         const modelEnt = this.modelEntry(this.ref);
+        // If we are not exporting the referenced structdef, don't use the reference
         if (modelEnt && !modelEnt.exported) {
-            // If we are not exporting the referenced structdef, don't
-            // use the reference
-            return this.structDef();
+            return {
+                structRef: this.structDef(parameterSpace),
+            };
+        }
+        return {
+            structRef: this.refName,
+            sourceArguments: this.evaluateArgumentsForRef(parameterSpace),
+        };
+    }
+    refLog(message, severity) {
+        if (typeof this.ref === 'string') {
+            this.log(message, severity);
+        }
+        else {
+            this.ref.log(message, severity);
         }
-        return this.refName;
     }
     modelStruct() {
         var _a;
@@ -95,7 +99,61 @@ class NamedSource extends source_1.Source {
         }
         return { ...entry };
     }
-    structDef() {
+    evaluateArgumentsForRef(parameterSpace) {
+        const base = this.modelStruct();
+        if (base === undefined) {
+            return {};
+        }
+        return this.evaluateArguments(parameterSpace, base.parameters, []);
+    }
+    evaluateArguments(parameterSpace, parametersIn, parametersOut) {
+        var _a, _b;
+        const outArguments = { ...this.sourceArguments };
+        const passedNames = new Set();
+        for (const argument of (_a = this.args) !== null && _a !== void 0 ? _a : []) {
+            const id = (_b = argument.id) !== null && _b !== void 0 ? _b : (argument.value instanceof expr_id_reference_1.ExprIdReference
+                ? argument.value.fieldReference
+                : undefined);
+            if (id === undefined) {
+                argument.value.log('Parameterized source arguments must be named with `parameter_name is`');
+                continue;
+            }
+            const name = id.outputName;
+            if (passedNames.has(name)) {
+                argument.log(`Cannot pass argument for \`${name}\` more than once`);
+                continue;
+            }
+            passedNames.add(name);
+            const parameter = (parametersIn !== null && parametersIn !== void 0 ? parametersIn : {})[name];
+            if (!parameter) {
+                id.log(`\`${this.refName}\` has no declared parameter named \`${id.refString}\``);
+            }
+            else {
+                const paramSpace = parameterSpace !== null && parameterSpace !== void 0 ? parameterSpace : new parameter_space_1.ParameterSpace(parametersOut !== null && parametersOut !== void 0 ? parametersOut : []);
+                const pVal = argument.value.getExpression(paramSpace);
+                let value = pVal.value;
+                if (pVal.dataType !== parameter.type && (0, malloy_types_1.isCastType)(parameter.type)) {
+                    value = (0, time_utils_1.castTo)(parameter.type, pVal.value, pVal.dataType, true);
+                }
+                outArguments[name] = {
+                    ...parameter,
+                    value,
+                };
+            }
+        }
+        for (const paramName in parametersIn) {
+            if (!(paramName in outArguments)) {
+                if (!(0, malloy_types_1.paramHasValue)(parametersIn[paramName])) {
+                    this.refLog(`Argument not provided for required parameter \`${paramName}\``);
+                }
+            }
+        }
+        return outArguments;
+    }
+    structDef(parameterSpace) {
+        return this.withParameters(parameterSpace, []);
+    }
+    withParameters(parameterSpace, pList) {
         /*
           Can't really generate the callback list until after all the
           things before me are translated, and that kinda screws up
@@ -109,50 +167,23 @@ class NamedSource extends source_1.Source {
           can do other translations and link them into a partial translation
           which might result in a full translation.
         */
-        var _a, _b;
-        const ret = this.modelStruct();
-        if (!ret) {
+        var _a;
+        const base = this.modelStruct();
+        if (!base) {
             const notFound = error_factory_1.ErrorFactory.structDef;
             const err = `${this.refName}-undefined`;
             notFound.name = notFound.name + err;
             notFound.dialect = notFound.dialect + err;
             return notFound;
         }
-        const declared = { ...ret.parameters };
-        const makeWith = ((_a = this.isBlock) === null || _a === void 0 ? void 0 : _a.isMap) || {};
-        for (const [pName, pExpr] of Object.entries(makeWith)) {
-            const decl = declared[pName];
-            // const pVal = pExpr.constantValue();
-            if (!decl) {
-                this.log(`Value given for undeclared parameter '${pName}`);
-            }
-            else {
-                if ((0, malloy_types_1.isValueParameter)(decl)) {
-                    if (decl.constant) {
-                        pExpr.log(`Cannot override constant parameter ${pName}`);
-                    }
-                    else {
-                        const pVal = pExpr.constantValue();
-                        let value = pVal.value;
-                        if (pVal.dataType !== decl.type && (0, malloy_types_1.isCastType)(decl.type)) {
-                            value = (0, time_utils_1.castTo)(decl.type, pVal.value, pVal.dataType, true);
-                        }
-                        decl.value = value;
-                    }
-                }
-                else {
-                    // TODO type checking here -- except I am still not sure what
-                    // datatype half conditions have ..
-                    decl.condition = pExpr.constantCondition(decl.type).value;
-                }
-            }
-        }
-        for (const checkDef in ret.parameters) {
-            if (!(0, malloy_types_1.paramHasValue)(declared[checkDef])) {
-                this.log(`Value not provided for required parameter ${checkDef}`);
-            }
+        const outParameters = {};
+        for (const parameter of pList !== null && pList !== void 0 ? pList : []) {
+            const compiled = parameter.parameter();
+            outParameters[compiled.name] = compiled;
         }
-        (_b = this.document()) === null || _b === void 0 ? void 0 : _b.rememberToAddModelAnnotations(ret);
+        const outArguments = this.evaluateArguments(parameterSpace, base.parameters, pList);
+        const ret = { ...base, parameters: outParameters, arguments: outArguments };
+        (_a = this.document()) === null || _a === void 0 ? void 0 : _a.rememberToAddModelAnnotations(ret);
         return ret;
     }
 }

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

@@ -1,9 +1,12 @@
 import { StructDef } from '../../../model/malloy_types';
 import { Source } from './source';
 import { QueryElement } from '../types/query-element';
+import { ParameterSpace } from '../field-space/parameter-space';
+import { HasParameter } from '../parameters/has-parameter';
 export declare class QuerySource extends Source {
     readonly query: QueryElement;
     elementType: string;
     constructor(query: QueryElement);
-    structDef(): StructDef;
+    structDef(parameterSpace: ParameterSpace | undefined): StructDef;
+    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): StructDef;
 }

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

@@ -26,11 +26,14 @@ exports.QuerySource = void 0;
 const source_1 = require("./source");
 class QuerySource extends source_1.Source {
     constructor(query) {
-        super({ query: query });
+        super({ query });
         this.query = query;
         this.elementType = 'querySource';
     }
-    structDef() {
+    structDef(parameterSpace) {
+        return this.withParameters(parameterSpace, undefined);
+    }
+    withParameters(parameterSpace, pList) {
         var _a;
         const comp = this.query.queryComp(false);
         const queryStruct = {
@@ -38,7 +41,10 @@ class QuerySource extends source_1.Source {
             structSource: { type: 'query', query: comp.query },
         };
         (_a = this.document()) === null || _a === void 0 ? void 0 : _a.rememberToAddModelAnnotations(queryStruct);
-        return queryStruct;
+        return {
+            ...queryStruct,
+            parameters: this.packParameters(pList),
+        };
     }
 }
 exports.QuerySource = QuerySource;

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

@@ -2,6 +2,7 @@ import { Annotation, StructDef } from '../../../model/malloy_types';
 import { HasParameter } from '../parameters/has-parameter';
 import { SourceDesc } from '../types/source-desc';
 import { Source } from './source';
+import { ParameterSpace } from '../field-space/parameter-space';
 /**
  * A Source made from a source reference and a set of refinements
  */
@@ -11,6 +12,6 @@ export declare class RefinedSource extends Source {
     elementType: string;
     currentAnnotation?: Annotation;
     constructor(source: Source, refinement: SourceDesc);
-    structDef(): StructDef;
-    withParameters(pList: HasParameter[] | undefined): StructDef;
+    structDef(parameterSpace: ParameterSpace | undefined): StructDef;
+    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): StructDef;
 }

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

@@ -35,20 +35,21 @@ const source_1 = require("./source");
 const timezone_statement_1 = require("../source-properties/timezone-statement");
 const annotation_elements_1 = require("../types/annotation-elements");
 const renames_1 = require("../source-properties/renames");
+const parameter_space_1 = require("../field-space/parameter-space");
 /**
  * A Source made from a source reference and a set of refinements
  */
 class RefinedSource extends source_1.Source {
     constructor(source, refinement) {
-        super({ source: source, refinement: refinement });
+        super({ source, refinement });
         this.source = source;
         this.refinement = refinement;
         this.elementType = 'refinedSource';
     }
-    structDef() {
-        return this.withParameters([]);
+    structDef(parameterSpace) {
+        return this.withParameters(parameterSpace, []);
     }
-    withParameters(pList) {
+    withParameters(parameterSpace, pList) {
         var _a;
         let primaryKey;
         let fieldListEdit;
@@ -91,18 +92,22 @@ class RefinedSource extends source_1.Source {
                 errTo.log(`Unexpected source property: '${errTo.elementType}'`);
             }
         }
-        const from = structuredClone(this.source.structDef());
+        const paramSpace = pList ? new parameter_space_1.ParameterSpace(pList) : undefined;
+        const from = structuredClone(this.source.structDef(paramSpace));
+        // Note that this is explicitly not:
+        // const from = structuredClone(this.source.withParameters(parameterSpace, pList));
+        // Because the parameters are added to the resulting struct, not the base struct
         if (primaryKey) {
             from.primaryKey = primaryKey.field.name;
         }
-        const fs = refined_space_1.RefinedSpace.filteredFrom(from, fieldListEdit);
+        const fs = refined_space_1.RefinedSpace.filteredFrom(from, fieldListEdit, paramSpace);
         if (newTimezone) {
             fs.setTimezone(newTimezone);
         }
-        fs.pushFields(...fields);
         if (pList) {
             fs.addParameters(pList);
         }
+        fs.pushFields(...fields);
         if (primaryKey) {
             const keyDef = primaryKey.field.getField(fs);
             if (keyDef.error) {

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

@@ -1,12 +1,14 @@
-import { StructDef, StructRef } from '../../../model/malloy_types';
+import { InvokedStructRef, Parameter, StructDef } from '../../../model/malloy_types';
 import { MalloyElement } from '../types/malloy-element';
 import { HasParameter } from '../parameters/has-parameter';
+import { ParameterSpace } from '../field-space/parameter-space';
 /**
  * A "Source" is a thing which you can run queries against. The main
  * function of a source is to represent an eventual StructDef
  */
 export declare abstract class Source extends MalloyElement {
-    abstract structDef(): StructDef;
-    structRef(): StructRef;
-    withParameters(pList: HasParameter[] | undefined): StructDef;
+    abstract structDef(parameterSpace: ParameterSpace | undefined): StructDef;
+    structRef(parameterSpace: ParameterSpace | undefined): InvokedStructRef;
+    protected packParameters(pList: HasParameter[] | undefined): Record<string, Parameter> | undefined;
+    withParameters(parameterSpace: ParameterSpace | undefined, pList: HasParameter[] | undefined): StructDef;
 }

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

@@ -29,24 +29,27 @@ const malloy_element_1 = require("../types/malloy-element");
  * function of a source is to represent an eventual StructDef
  */
 class Source extends malloy_element_1.MalloyElement {
-    structRef() {
-        return this.structDef();
+    structRef(parameterSpace) {
+        return {
+            structRef: this.structDef(parameterSpace),
+        };
     }
-    withParameters(pList) {
-        const before = this.structDef();
-        // TODO name collisions are flagged where?
-        if (pList) {
-            const parameters = { ...(before.parameters || {}) };
-            for (const hasP of pList) {
-                const pVal = hasP.parameter();
-                parameters[pVal.name] = pVal;
-            }
-            return {
-                ...before,
-                parameters,
-            };
+    packParameters(pList) {
+        if (pList === undefined)
+            return undefined;
+        const parameters = {};
+        for (const hasP of pList) {
+            const pVal = hasP.parameter();
+            parameters[pVal.name] = pVal;
         }
-        return before;
+        return parameters;
+    }
+    withParameters(parameterSpace, pList) {
+        const before = this.structDef(parameterSpace);
+        return {
+            ...before,
+            parameters: this.packParameters(pList),
+        };
     }
 }
 exports.Source = Source;

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

@@ -1,4 +1,4 @@
-import { StructDef, StructRef, SQLBlockSource } from '../../../model/malloy_types';
+import { StructDef, SQLBlockSource, InvokedStructRef } from '../../../model/malloy_types';
 import { NeedCompileSQL } from '../../translate-response';
 import { Source } from './source';
 import { SQLString } from '../sql-elements/sql-string';
@@ -11,7 +11,7 @@ export declare class SQLSource extends Source {
     private connectionNameInvalid;
     constructor(connectionName: ModelEntryReference, select: SQLString);
     sqlBlock(): SQLBlockSource;
-    structRef(): StructRef;
+    structRef(): InvokedStructRef;
     validateConnectionName(): boolean;
     needs(doc: Document): NeedCompileSQL | undefined;
     structDef(): StructDef;

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

@@ -28,12 +28,11 @@ const source_1 = require("./source");
 const error_factory_1 = require("../error-factory");
 class SQLSource extends source_1.Source {
     constructor(connectionName, select) {
-        super();
+        super({ connectionName, select });
         this.connectionName = connectionName;
         this.select = select;
         this.elementType = 'sqlSource';
         this.connectionNameInvalid = false;
-        this.has({ connectionName, select });
     }
     sqlBlock() {
         if (!this.requestBlock) {
@@ -42,7 +41,9 @@ class SQLSource extends source_1.Source {
         return this.requestBlock;
     }
     structRef() {
-        return this.structDef();
+        return {
+            structRef: this.structDef(),
+        };
     }
     validateConnectionName() {
         var _a;

package/dist/lang/ast/source-properties/joins.d.ts

@@ -9,16 +9,17 @@ import { extendNoteMethod, Noteable } from '../types/noteable';
 import { LegalRefinementStage, QueryPropertyInterface } from '../types/query-property-interface';
 import { MakeEntry } from '../types/space-entry';
 import { SourceQueryElement } from '../source-query-elements/source-query-element';
+import { ParameterSpace } from '../field-space/parameter-space';
 export declare abstract class Join extends MalloyElement implements Noteable, MakeEntry {
     abstract name: ModelEntryReference;
-    abstract structDef(): StructDef;
+    abstract structDef(parameterSpace: ParameterSpace): StructDef;
     abstract fixupJoinOn(outer: FieldSpace, inStruct: StructDef): void;
     readonly isNoteableObj = true;
     extendNote: typeof extendNoteMethod;
     abstract sourceExpr: SourceQueryElement;
     note?: Annotation;
     makeEntry(fs: DynamicSpace): void;
-    protected getStructDefFromExpr(): StructDef;
+    protected getStructDefFromExpr(parameterSpace: ParameterSpace): StructDef;
 }
 export declare class KeyJoin extends Join {
     readonly name: ModelEntryReference;
@@ -26,7 +27,7 @@ export declare class KeyJoin extends Join {
     readonly keyExpr: ExpressionDef;
     elementType: string;
     constructor(name: ModelEntryReference, sourceExpr: SourceQueryElement, keyExpr: ExpressionDef);
-    structDef(): StructDef;
+    structDef(parameterSpace: ParameterSpace): StructDef;
     fixupJoinOn(outer: FieldSpace, inStruct: StructDef): void;
 }
 type ExpressionJoinType = 'many' | 'one' | 'cross';
@@ -42,7 +43,7 @@ export declare class ExpressionJoin extends Join {
     set joinOn(joinExpr: ExpressionDef | undefined);
     get joinOn(): ExpressionDef | undefined;
     fixupJoinOn(outer: FieldSpace, inStruct: StructDef): Expr | undefined;
-    structDef(): StructDef;
+    structDef(parameterSpace: ParameterSpace): StructDef;
 }
 export declare class Joins extends DefinitionList<Join> implements QueryPropertyInterface {
     elementType: string;