@malloydata/malloy 0.0.22-dev230126015148 → 0.0.22-dev230202171033

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

@@ -0,0 +1,100 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FT = void 0;
+function mkFragType(dType) {
+    return { dataType: dType, expressionType: "scalar" };
+}
+/**
+ * Collects functions which operate on fragtype compatible objects
+ */
+class FT {
+    /**
+     * Checks if a given type is in a list
+     * @param check The type to check (can be undefined)
+     * @param from List of types which are OK
+     */
+    static in(check, from) {
+        if (check) {
+            const found = from.find((okType) => FT.eq(okType, check));
+            return found !== undefined;
+        }
+        return false;
+    }
+    /**
+     * Checks if a possibly undefined candidate matches a type
+     * @param good The real type
+     * @param checkThis The possibly undefined candidate
+     */
+    static eq(good, checkThis) {
+        return (checkThis !== undefined &&
+            good.dataType === checkThis.dataType &&
+            good.expressionType === checkThis.expressionType);
+    }
+    /**
+     * Checks if the base types, ignoring aggregate, are equal
+     * @param left Left type
+     * @param right Right type
+     * @param nullOk True if a NULL is an acceptable match
+     */
+    static typeEq(left, right, nullOk = false) {
+        const maybeEq = left.dataType === right.dataType;
+        const nullEq = nullOk && (left.dataType === "null" || right.dataType === "null");
+        return maybeEq || nullEq;
+    }
+    /**
+     *
+     * For error messages, returns a comma seperated list of readable names
+     * for a list of types.
+     * @param types List of type or objects with types
+     */
+    static inspect(...types) {
+        const strings = types.map((type) => {
+            if (type) {
+                let inspected = type.dataType;
+                if (type.expressionType != "scalar") {
+                    inspected = `${type.expressionType} ${inspected}`;
+                }
+                return inspected;
+            }
+            return "undefined";
+        });
+        return strings.join(",");
+    }
+}
+exports.FT = FT;
+FT.nullT = mkFragType("null");
+FT.numberT = mkFragType("number");
+FT.stringT = mkFragType("string");
+FT.dateT = mkFragType("date");
+FT.timestampT = mkFragType("timestamp");
+FT.boolT = mkFragType("boolean");
+FT.anyAtomicT = [
+    FT.numberT,
+    FT.stringT,
+    FT.dateT,
+    FT.timestampT,
+    FT.boolT,
+];
+//# sourceMappingURL=fragtype-utils.js.map

package/dist/lang/ast/import-elements/import-statement.d.ts

@@ -0,0 +1,9 @@
+import { ModelDataRequest } from "../../parse-malloy";
+import { DocStatement, Document, MalloyElement } from "../types/malloy-element";
+export declare class ImportStatement extends MalloyElement implements DocStatement {
+    readonly url: string;
+    elementType: string;
+    fullURL?: string;
+    constructor(url: string, baseURL: string);
+    execute(doc: Document): ModelDataRequest;
+}

package/dist/lang/ast/import-elements/import-statement.js

@@ -0,0 +1,78 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportStatement = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class ImportStatement extends malloy_element_1.MalloyElement {
+    /*
+     * At the time of writng this comment, it is guaranteed that if an AST
+     * node for an import statement is created, the translator has already
+     * succesfully fetched the URL referred to in the statement.
+     *
+     * Error checking code in here is future proofing against a day when
+     * there are other ways to contruct an AST.
+     */
+    constructor(url, baseURL) {
+        super();
+        this.url = url;
+        this.elementType = "import statement";
+        try {
+            this.fullURL = decodeURI(new URL(url, baseURL).toString());
+        }
+        catch (e) {
+            this.log("Invalid URI in import statement");
+        }
+    }
+    execute(doc) {
+        const trans = this.translator();
+        if (!trans) {
+            this.log("Cannot import without translation context");
+        }
+        else if (this.fullURL) {
+            const src = trans.root.importZone.getEntry(this.fullURL);
+            if (src.status === "present") {
+                const childNeeds = trans.childRequest(this.fullURL);
+                if (childNeeds) {
+                    return childNeeds;
+                }
+                const importStructs = trans.getChildExports(this.fullURL);
+                for (const importing in importStructs) {
+                    doc.setEntry(importing, {
+                        entry: importStructs[importing],
+                        exported: false,
+                    });
+                }
+            }
+            else if (src.status === "error") {
+                this.log(`import failed: '${src.message}'`);
+            }
+            else {
+                this.log(`import failed with status: '${src.status}'`);
+            }
+        }
+        return undefined;
+    }
+}
+exports.ImportStatement = ImportStatement;
+//# sourceMappingURL=import-statement.js.map

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

@@ -1,5 +1,96 @@
-export * from "./ast-types";
 export * from "./ast-main";
-export * from "./ast-expr";
-export * from "./ast-time-expr";
+export * from "./ast-utils";
+export * from "./elements/define-explore";
+export * from "./elements/define-query";
+export * from "./elements/mallobj";
+export * from "./elements/refined-explore";
+export * from "./explore-properties/field-list-edit";
+export * from "./explore-properties/primary-key";
+export * from "./explore-properties/renames";
+export * from "./explore-properties/turtles";
+export * from "./expressions/apply";
+export * from "./expressions/binary-numeric";
+export * from "./expressions/boolean";
+export * from "./expressions/expr-add-sub";
+export * from "./expressions/expr-aggregate-function";
+export * from "./expressions/expr-alternation-tree";
+export * from "./expressions/expr-asymmetric";
+export * from "./expressions/expr-avg";
+export * from "./expressions/expr-case";
+export * from "./expressions/expr-cast";
+export * from "./expressions/expr-compare";
+export * from "./expressions/expr-count";
+export * from "./expressions/expr-count-distinct";
+export * from "./expressions/expr-filter";
+export * from "./expressions/expr-func";
+export * from "./expressions/expr-granular-time";
+export * from "./expressions/expr-id-reference";
+export * from "./expressions/expr-logical-op";
+export * from "./expressions/expr-max";
+export * from "./expressions/expr-min";
+export * from "./expressions/expr-minus";
+export * from "./expressions/expr-mul-div";
+export * from "./expressions/expr-not";
+export * from "./expressions/expr-now";
+export * from "./expressions/expr-null";
+export * from "./expressions/expr-number";
+export * from "./expressions/expr-parens";
+export * from "./expressions/expr-regex";
+export * from "./expressions/expr-string";
+export * from "./expressions/expr-sum";
+export * from "./expressions/expr-time-extract";
+export * from "./expressions/expr-ungroup";
+export * from "./expressions/for-range";
+export * from "./expressions/granular-literal";
+export * from "./expressions/partial-compare";
+export * from "./expressions/pick-when";
+export * from "./expressions/range";
+export * from "./expressions/time-frame";
+export * from "./expressions/top-by";
+export * from "./expressions/unary";
+export * from "./expressions/utils";
+export * from "./expressions/when-clause";
+export * from "./import-elements/import-statement";
+export * from "./nesting/nest-reference";
+export * from "./parameters/has-parameter";
+export * from "./query-elements/anonymous-query";
+export * from "./query-elements/existing-query";
+export * from "./query-elements/full-query";
+export * from "./query-items/field-declaration";
+export * from "./query-items/field-references";
+export * from "./query-properties/aggregate";
+export * from "./query-properties/declare-fields";
+export * from "./query-properties/dimmensions";
+export * from "./query-properties/filters";
+export * from "./query-properties/group-by";
+export * from "./query-properties/indexing";
+export * from "./query-properties/joins";
+export * from "./query-properties/limit";
+export * from "./query-properties/measures";
+export * from "./query-properties/nests";
+export * from "./query-properties/ordering";
+export * from "./query-properties/project-statement";
+export * from "./query-properties/qop-desc";
+export * from "./query-properties/sampling";
+export * from "./query-properties/top";
+export * from "./sources/named-source";
+export * from "./sources/query-source";
+export * from "./sources/sql-source";
+export * from "./sources/table-source";
+export * from "./sql-elements/sql-statement";
+export * from "./sql-elements/sql-string";
 export * from "./time-utils";
+export * from "./types/comparison";
+export * from "./types/compart-types";
+export * from "./types/explore-desc";
+export * from "./types/explore-property";
+export * from "./types/expression-def";
+export * from "./types/field-collection-member";
+export * from "./types/field-space";
+export * from "./types/malloy-element";
+export * from "./types/nested-query";
+export * from "./types/query-element";
+export * from "./types/query-item";
+export * from "./types/query-property";
+export * from "./types/stage-field-type";
+export * from "./types/turtle-headed-pipe";

package/dist/lang/ast/index.js

@@ -36,9 +36,100 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ast-types"), exports);
 __exportStar(require("./ast-main"), exports);
-__exportStar(require("./ast-expr"), exports);
-__exportStar(require("./ast-time-expr"), exports);
+__exportStar(require("./ast-utils"), exports);
+__exportStar(require("./elements/define-explore"), exports);
+__exportStar(require("./elements/define-query"), exports);
+__exportStar(require("./elements/mallobj"), exports);
+__exportStar(require("./elements/refined-explore"), exports);
+__exportStar(require("./explore-properties/field-list-edit"), exports);
+__exportStar(require("./explore-properties/primary-key"), exports);
+__exportStar(require("./explore-properties/renames"), exports);
+__exportStar(require("./explore-properties/turtles"), exports);
+__exportStar(require("./expressions/apply"), exports);
+__exportStar(require("./expressions/binary-numeric"), exports);
+__exportStar(require("./expressions/boolean"), exports);
+__exportStar(require("./expressions/expr-add-sub"), exports);
+__exportStar(require("./expressions/expr-aggregate-function"), exports);
+__exportStar(require("./expressions/expr-alternation-tree"), exports);
+__exportStar(require("./expressions/expr-asymmetric"), exports);
+__exportStar(require("./expressions/expr-avg"), exports);
+__exportStar(require("./expressions/expr-case"), exports);
+__exportStar(require("./expressions/expr-cast"), exports);
+__exportStar(require("./expressions/expr-compare"), exports);
+__exportStar(require("./expressions/expr-count"), exports);
+__exportStar(require("./expressions/expr-count-distinct"), exports);
+__exportStar(require("./expressions/expr-filter"), exports);
+__exportStar(require("./expressions/expr-func"), exports);
+__exportStar(require("./expressions/expr-granular-time"), exports);
+__exportStar(require("./expressions/expr-id-reference"), exports);
+__exportStar(require("./expressions/expr-logical-op"), exports);
+__exportStar(require("./expressions/expr-max"), exports);
+__exportStar(require("./expressions/expr-min"), exports);
+__exportStar(require("./expressions/expr-minus"), exports);
+__exportStar(require("./expressions/expr-mul-div"), exports);
+__exportStar(require("./expressions/expr-not"), exports);
+__exportStar(require("./expressions/expr-now"), exports);
+__exportStar(require("./expressions/expr-null"), exports);
+__exportStar(require("./expressions/expr-number"), exports);
+__exportStar(require("./expressions/expr-parens"), exports);
+__exportStar(require("./expressions/expr-regex"), exports);
+__exportStar(require("./expressions/expr-string"), exports);
+__exportStar(require("./expressions/expr-sum"), exports);
+__exportStar(require("./expressions/expr-time-extract"), exports);
+__exportStar(require("./expressions/expr-ungroup"), exports);
+__exportStar(require("./expressions/for-range"), exports);
+__exportStar(require("./expressions/granular-literal"), exports);
+__exportStar(require("./expressions/partial-compare"), exports);
+__exportStar(require("./expressions/pick-when"), exports);
+__exportStar(require("./expressions/range"), exports);
+__exportStar(require("./expressions/time-frame"), exports);
+__exportStar(require("./expressions/top-by"), exports);
+__exportStar(require("./expressions/unary"), exports);
+__exportStar(require("./expressions/utils"), exports);
+__exportStar(require("./expressions/when-clause"), exports);
+__exportStar(require("./import-elements/import-statement"), exports);
+__exportStar(require("./nesting/nest-reference"), exports);
+__exportStar(require("./parameters/has-parameter"), exports);
+__exportStar(require("./query-elements/anonymous-query"), exports);
+__exportStar(require("./query-elements/existing-query"), exports);
+__exportStar(require("./query-elements/full-query"), exports);
+__exportStar(require("./query-items/field-declaration"), exports);
+__exportStar(require("./query-items/field-references"), exports);
+__exportStar(require("./query-properties/aggregate"), exports);
+__exportStar(require("./query-properties/declare-fields"), exports);
+__exportStar(require("./query-properties/dimmensions"), exports);
+__exportStar(require("./query-properties/filters"), exports);
+__exportStar(require("./query-properties/group-by"), exports);
+__exportStar(require("./query-properties/indexing"), exports);
+__exportStar(require("./query-properties/joins"), exports);
+__exportStar(require("./query-properties/limit"), exports);
+__exportStar(require("./query-properties/measures"), exports);
+__exportStar(require("./query-properties/nests"), exports);
+__exportStar(require("./query-properties/ordering"), exports);
+__exportStar(require("./query-properties/project-statement"), exports);
+__exportStar(require("./query-properties/qop-desc"), exports);
+__exportStar(require("./query-properties/sampling"), exports);
+__exportStar(require("./query-properties/top"), exports);
+__exportStar(require("./sources/named-source"), exports);
+__exportStar(require("./sources/query-source"), exports);
+__exportStar(require("./sources/sql-source"), exports);
+__exportStar(require("./sources/table-source"), exports);
+__exportStar(require("./sql-elements/sql-statement"), exports);
+__exportStar(require("./sql-elements/sql-string"), exports);
 __exportStar(require("./time-utils"), exports);
+__exportStar(require("./types/comparison"), exports);
+__exportStar(require("./types/compart-types"), exports);
+__exportStar(require("./types/explore-desc"), exports);
+__exportStar(require("./types/explore-property"), exports);
+__exportStar(require("./types/expression-def"), exports);
+__exportStar(require("./types/field-collection-member"), exports);
+__exportStar(require("./types/field-space"), exports);
+__exportStar(require("./types/malloy-element"), exports);
+__exportStar(require("./types/nested-query"), exports);
+__exportStar(require("./types/query-element"), exports);
+__exportStar(require("./types/query-item"), exports);
+__exportStar(require("./types/query-property"), exports);
+__exportStar(require("./types/stage-field-type"), exports);
+__exportStar(require("./types/turtle-headed-pipe"), exports);
 //# sourceMappingURL=index.js.map

package/dist/lang/ast/json-elements/json-element.d.ts

@@ -0,0 +1,6 @@
+import { MalloyElement } from "../types/malloy-element";
+export declare class JSONElement extends MalloyElement {
+    elementType: string;
+    readonly value: any;
+    constructor(jsonSrc: string);
+}

package/dist/lang/ast/json-elements/json-element.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONElement = void 0;
+const malloy_element_1 = require("../types/malloy-element");
+class JSONElement extends malloy_element_1.MalloyElement {
+    constructor(jsonSrc) {
+        super();
+        this.elementType = "jsonElement";
+        try {
+            this.value = JSON.parse(jsonSrc);
+        }
+        catch (SyntaxError) {
+            this.log("JSON syntax error");
+            this.value = undefined;
+        }
+    }
+}
+exports.JSONElement = JSONElement;
+//# sourceMappingURL=json-element.js.map

package/dist/lang/ast/json-elements/json-struct-def.d.ts

@@ -0,0 +1,10 @@
+import { StructDef } from "../../../model/malloy_types";
+import { Mallobj } from "../elements/mallobj";
+import { JSONElement } from "./json-element";
+export declare class JSONStructDef extends Mallobj {
+    readonly struct: StructDef;
+    elementType: string;
+    constructor(struct: StructDef);
+    static fromJSON(jsonObj: JSONElement): JSONStructDef | undefined;
+    structDef(): StructDef;
+}

package/dist/lang/ast/json-elements/json-struct-def.js

@@ -0,0 +1,48 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONStructDef = void 0;
+const mallobj_1 = require("../elements/mallobj");
+class JSONStructDef extends mallobj_1.Mallobj {
+    constructor(struct) {
+        super();
+        this.struct = struct;
+        this.elementType = "jsonStructDef";
+    }
+    static fromJSON(jsonObj) {
+        const obj = jsonObj.value;
+        if (obj &&
+            obj.type === "struct" &&
+            obj.structRelationship &&
+            obj.structSource) {
+            return new JSONStructDef(obj);
+        }
+        return undefined;
+    }
+    structDef() {
+        return this.struct;
+    }
+}
+exports.JSONStructDef = JSONStructDef;
+//# sourceMappingURL=json-struct-def.js.map

package/dist/lang/ast/nesting/nest-reference.d.ts

@@ -0,0 +1,7 @@
+import { FieldReference } from "../query-items/field-references";
+import { FieldName } from "../types/field-space";
+export declare class NestReference extends FieldReference {
+    readonly name: FieldName;
+    elementType: string;
+    constructor(name: FieldName);
+}

package/dist/lang/ast/nesting/nest-reference.js

@@ -0,0 +1,35 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestReference = void 0;
+const field_references_1 = require("../query-items/field-references");
+class NestReference extends field_references_1.FieldReference {
+    constructor(name) {
+        super([name]);
+        this.name = name;
+        this.elementType = "nestReference";
+    }
+}
+exports.NestReference = NestReference;
+//# sourceMappingURL=nest-reference.js.map

package/dist/lang/ast/parameters/constant-parameter.d.ts

@@ -0,0 +1,8 @@
+import { Parameter } from "../../../model/malloy_types";
+import { ConstantSubExpression } from "../expressions/constant-sub-expression";
+import { HasParameter } from "./has-parameter";
+export declare class ConstantParameter extends HasParameter {
+    readonly value: ConstantSubExpression;
+    constructor(name: string, value: ConstantSubExpression);
+    parameter(): Parameter;
+}

package/dist/lang/ast/parameters/constant-parameter.js

@@ -0,0 +1,54 @@
+"use strict";
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files
+ * (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantParameter = void 0;
+const malloy_types_1 = require("../../../model/malloy_types");
+const has_parameter_1 = require("./has-parameter");
+class ConstantParameter extends has_parameter_1.HasParameter {
+    constructor(name, value) {
+        super({ name, isCondition: false });
+        this.value = value;
+        this.has({ value });
+    }
+    parameter() {
+        const cVal = this.value.constantValue();
+        if (!(0, malloy_types_1.isAtomicFieldType)(cVal.dataType)) {
+            this.log(`Unexpected expression type '${cVal.dataType}'`);
+            return {
+                value: ["XXX-type-mismatch-error-XXX"],
+                type: "string",
+                name: this.name,
+                constant: true,
+            };
+        }
+        return {
+            value: cVal.value,
+            type: cVal.dataType,
+            name: this.name,
+            constant: true,
+        };
+    }
+}
+exports.ConstantParameter = ConstantParameter;
+//# sourceMappingURL=constant-parameter.js.map

package/dist/lang/ast/parameters/has-parameter.d.ts

@@ -0,0 +1,19 @@
+import { AtomicFieldType, Parameter } from "../../../model/malloy_types";
+import { ConstantSubExpression } from "../expressions/constant-sub-expression";
+import { MalloyElement } from "../types/malloy-element";
+interface HasInit {
+    name: string;
+    isCondition: boolean;
+    type?: string;
+    default?: ConstantSubExpression;
+}
+export declare class HasParameter extends MalloyElement {
+    elementType: string;
+    readonly name: string;
+    readonly isCondition: boolean;
+    readonly type?: AtomicFieldType;
+    readonly default?: ConstantSubExpression;
+    constructor(init: HasInit);
+    parameter(): Parameter;
+}
+export {};