@malloydata/malloy 0.0.276 → 0.0.278

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

@@ -1,20 +1,18 @@
-import type { FilterableType } from '@malloydata/malloy-filter';
-import type { Parameter, ParameterType } from '../../../model/malloy_types';
+import type { Parameter, ParameterTypeDef } from '../../../model/malloy_types';
 import type { ConstantExpression } from '../expressions/constant-expression';
 import { MalloyElement } from '../types/malloy-element';
 interface HasInit {
     name: string;
-    type?: ParameterType;
-    filterType?: FilterableType;
+    typeDef?: ParameterTypeDef;
     default?: ConstantExpression;
 }
 export declare class HasParameter extends MalloyElement {
     elementType: string;
     readonly name: string;
-    readonly type?: ParameterType;
+    readonly typeDef?: ParameterTypeDef;
     readonly default?: ConstantExpression;
-    readonly filterType?: FilterableType;
     constructor(init: HasInit);
+    private get type();
     parameter(): Parameter;
 }
 export {};

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

@@ -31,19 +31,25 @@ class HasParameter extends malloy_element_1.MalloyElement {
         super();
         this.elementType = 'hasParameter';
         this.name = init.name;
-        if (init.type && (0, malloy_types_1.isParameterType)(init.type)) {
-            this.type = init.type;
+        if (init.typeDef) {
+            this.typeDef = init.typeDef;
         }
         if (init.default) {
             this.default = init.default;
             this.has({ default: this.default });
         }
-        if (init.filterType)
-            this.filterType = init.filterType;
+    }
+    get type() {
+        var _a;
+        return (_a = this.typeDef) === null || _a === void 0 ? void 0 : _a.type;
     }
     parameter() {
         var _a;
-        let paramReturn;
+        const paramReturn = {
+            ...(this.typeDef || { type: 'error' }),
+            value: null,
+            name: this.name,
+        };
         if (this.default !== undefined) {
             const constant = this.default.constantValue();
             if (this.type &&
@@ -55,9 +61,8 @@ class HasParameter extends malloy_element_1.MalloyElement {
             if (constant.type === 'null') {
                 if (this.type) {
                     return {
-                        type: this.type,
+                        ...paramReturn,
                         value: constant.value,
-                        name: this.name,
                     };
                 }
                 else {
@@ -70,40 +75,33 @@ class HasParameter extends malloy_element_1.MalloyElement {
                 }
             }
             if (constant.type === 'filter expression') {
-                if (this.type !== 'filter expression') {
+                if (((_a = this.typeDef) === null || _a === void 0 ? void 0 : _a.type) !== 'filter expression') {
                     this.logError('parameter-missing-default-or-type', `Filter expression parameters must have expicit filter type, for example '${this.name}::filter<string>'`);
+                    return { ...paramReturn, type: 'error' };
                 }
-                if (this.filterType) {
-                    (0, expression_def_1.checkFilterExpression)(this, this.filterType, constant.value);
-                }
+                (0, expression_def_1.checkFilterExpression)(this, this.typeDef.filterType, constant.value);
                 return {
-                    value: constant.value,
+                    type: 'filter expression',
+                    filterType: this.typeDef.filterType,
                     name: this.name,
-                    type: constant.type,
+                    value: constant.value,
                 };
             }
-            if (!(0, malloy_types_1.isCastType)(constant.type) && constant.type !== 'error') {
+            if (!(0, malloy_types_1.isParameterType)(constant.type)) {
                 this.default.logError('parameter-illegal-default-type', `Default value cannot have type \`${constant.type}\``);
                 return {
-                    value: constant.value,
-                    name: this.name,
+                    ...paramReturn,
                     type: 'error',
                 };
             }
-            paramReturn = {
-                value: constant.value,
-                name: this.name,
-                type: constant.type,
-            };
+            paramReturn.type = constant.type;
+            paramReturn.value = constant.value;
         }
         else {
             if (this.type === undefined) {
                 this.logError('parameter-missing-default-or-type', 'Parameter must have default value or declared type');
+                paramReturn.type = 'error';
             }
-            paramReturn = { value: null, name: this.name, type: (_a = this.type) !== null && _a !== void 0 ? _a : 'error' };
-        }
-        if (paramReturn.type === 'filter expression' && this.filterType) {
-            paramReturn.filterType = this.filterType;
         }
         return paramReturn;
     }

package/dist/lang/malloy-to-ast.js

@@ -264,35 +264,30 @@ class MalloyToAST extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     getSourceParameter(pcx) {
         const name = (0, parse_utils_1.getId)(pcx.parameterNameDef());
         let pType;
-        let filterType;
         const typeCx = pcx.legalParamType();
         if (typeCx) {
-            const fTypeCx = typeCx.malloyType();
-            if (fTypeCx) {
-                const t = this.getMalloyType(fTypeCx);
+            const t = this.getMalloyType(typeCx.malloyType());
+            if (typeCx.FILTER()) {
                 if ((0, malloy_filter_1.isFilterable)(t)) {
-                    filterType = t;
+                    pType = { type: 'filter expression', filterType: t };
                 }
                 else {
                     this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown filter type ${t}`);
                 }
             }
-            const parseType = typeCx.FILTER()
-                ? 'filter expression'
-                : typeCx.text.toLowerCase();
-            if (!(0, malloy_types_1.isParameterType)(parseType)) {
-                this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown parameter type ${parseType}`);
-                return null;
+            else if ((0, malloy_types_1.isParameterType)(t)) {
+                pType = { type: t };
+            }
+            else {
+                this.contextError(typeCx, 'parameter-illegal-default-type', `Unknown parameter type ${t}`);
             }
-            pType = parseType;
         }
         const defaultCx = pcx.fieldExpr();
         let defVal;
         if (defaultCx) {
-            const defaultExpr = new ast.ConstantExpression(this.getFieldExpr(defaultCx));
-            defVal = this.astAt(defaultExpr, defaultCx);
+            defVal = this.astAt(new ast.ConstantExpression(this.getFieldExpr(defaultCx)), defaultCx);
         }
-        return this.astAt(new ast.HasParameter({ name, type: pType, default: defVal, filterType }), pcx);
+        return this.astAt(new ast.HasParameter({ name, typeDef: pType, default: defVal }), pcx);
     }
     getSourceParameters(pcx) {
         if (pcx === undefined)

package/dist/model/malloy_types.d.ts

@@ -269,13 +269,13 @@ interface ParameterInfo {
     name: string;
     value: ConstantExpr | null;
 }
-export interface FilterExpressionDef {
+interface FilterExpressionParamTypeDef {
     type: 'filter expression';
-    filterType?: FilterExprType;
+    filterType: FilterExprType;
 }
-export type ParameterType = CastType | 'filter expression';
+export type ParameterType = 'string' | 'number' | 'boolean' | 'date' | 'timestamp' | 'filter expression' | 'error';
 export declare function isParameterType(t: string): t is ParameterType;
-export type ParameterTypeDef = AtomicTypeDef | FilterExpressionDef;
+export type ParameterTypeDef = StringTypeDef | NumberTypeDef | BooleanTypeDef | TemporalTypeDef | FilterExpressionParamTypeDef | ErrorTypeDef;
 export type Parameter = ParameterTypeDef & ParameterInfo;
 export type Argument = Parameter;
 export declare function paramHasValue(p: Parameter): boolean;

package/dist/model/malloy_types.js

@@ -76,7 +76,15 @@ function isFilterExprType(s) {
 }
 exports.isFilterExprType = isFilterExprType;
 function isParameterType(t) {
-    return isCastType(t) || t === 'filter expression';
+    return [
+        'string',
+        'number',
+        'boolean',
+        'date',
+        'timestamp',
+        'filter expression',
+        'error',
+    ].includes(t);
 }
 exports.isParameterType = isParameterType;
 function paramHasValue(p) {

package/dist/to_stable.js

@@ -31,7 +31,12 @@ function modelDefToModelInfo(modelDef) {
                     }
                     return {
                         name,
-                        type: { kind: 'filter_expression_type' },
+                        type: {
+                            kind: 'filter_expression_type',
+                            filter_type: {
+                                kind: `${parameter.filterType}_type`,
+                            },
+                        },
                         default_value: convertParameterDefaultValue(parameter.value),
                     };
                 })

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.276";
+export declare const MALLOY_VERSION = "0.0.278";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.276';
+exports.MALLOY_VERSION = '0.0.278';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.276",
+  "version": "0.0.278",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,9 +41,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.276",
-    "@malloydata/malloy-interfaces": "0.0.276",
-    "@malloydata/malloy-tag": "0.0.276",
+    "@malloydata/malloy-filter": "0.0.278",
+    "@malloydata/malloy-interfaces": "0.0.278",
+    "@malloydata/malloy-tag": "0.0.278",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",