@malloydata/malloy 0.0.298 → 0.0.300

package/dist/api/asynchronous.d.ts

@@ -10,4 +10,4 @@ export interface CompilerNeedFetch<T extends InfoConnection> {
 export declare function compileModel(request: Malloy.CompileModelRequest, fetchers: CompilerNeedFetch<InfoConnection>): Promise<Malloy.CompileModelResponse>;
 export declare function compileSource(request: Malloy.CompileSourceRequest, fetchers: CompilerNeedFetch<InfoConnection>): Promise<Malloy.CompileSourceResponse>;
 export declare function compileQuery(request: Malloy.CompileQueryRequest, fetchers: CompilerNeedFetch<InfoConnection>): Promise<Malloy.CompileQueryResponse>;
-export declare function runQuery(request: Malloy.CompileQueryRequest, fetchers: CompilerNeedFetch<Connection>): Promise<Malloy.CompileQueryResponse>;
+export declare function runQuery(request: Malloy.RunQueryRequest, fetchers: CompilerNeedFetch<Connection>): Promise<Malloy.RunQueryResponse>;

package/dist/api/core.d.ts

@@ -27,6 +27,7 @@ export interface CompileModelState {
     translator: MalloyTranslator;
     done: boolean;
     hasSource: boolean;
+    excludeReferences: boolean;
 }
 export declare function updateCompileModelState(state: CompileModelState, needs: Malloy.CompilerNeeds | undefined): void;
 export declare function newCompileModelState(request: Malloy.CompileModelRequest): CompileModelState;

package/dist/api/core.js

@@ -258,17 +258,19 @@ function updateCompileModelState(state, needs) {
     const update = compilerNeedsToUpdate(needs);
     performUpdate(state, update);
 }
-function _newCompileModelState(modelURL, compilerNeeds, extendURL) {
+function _newCompileModelState(modelURL, compilerNeeds, parseUpdate, extendURL, excludeReferences = false) {
     var _a, _b, _c, _d;
-    const translator = new lang_1.MalloyTranslator(modelURL, null, compilerNeedsToUpdate(compilerNeeds));
+    parseUpdate !== null && parseUpdate !== void 0 ? parseUpdate : (parseUpdate = compilerNeedsToUpdate(compilerNeeds));
+    const translator = new lang_1.MalloyTranslator(modelURL, null, parseUpdate);
     const hasSource = ((_b = (_a = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.files) === null || _a === void 0 ? void 0 : _a.some(f => f.url === modelURL)) !== null && _b !== void 0 ? _b : false) ||
         ((_d = (_c = compilerNeeds === null || compilerNeeds === void 0 ? void 0 : compilerNeeds.translations) === null || _c === void 0 ? void 0 : _c.some(t => t.url === modelURL)) !== null && _d !== void 0 ? _d : false);
     if (extendURL) {
         return {
-            extending: _newCompileModelState(extendURL, compilerNeeds),
+            extending: _newCompileModelState(extendURL, compilerNeeds, parseUpdate, undefined, excludeReferences),
             translator,
             done: false,
             hasSource,
+            excludeReferences,
         };
     }
     else {
@@ -276,14 +278,15 @@ function _newCompileModelState(modelURL, compilerNeeds, extendURL) {
             translator,
             done: false,
             hasSource,
+            excludeReferences,
         };
     }
 }
 function newCompileModelState(request) {
-    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url);
+    return _newCompileModelState(request.model_url, request.compiler_needs, undefined, request.extend_model_url, request.exclude_references);
 }
 function newCompileSourceState(request) {
-    return _newCompileModelState(request.model_url, request.compiler_needs, request.extend_model_url);
+    return _newCompileModelState(request.model_url, request.compiler_needs, undefined, request.extend_model_url, request.exclude_references);
 }
 // function hasNeeds(needs: Malloy.CompilerNeeds | undefined): boolean {
 //   if (needs === undefined) return false;
@@ -328,7 +331,7 @@ function _statedCompileModel(state) {
             const model = (0, to_stable_1.modelDefToModelInfo)(result.modelDef);
             return {
                 model,
-                modelDef: result.modelDef,
+                modelDef: maybeExcludeReferences(result.modelDef, state.excludeReferences),
                 timingInfo,
             };
         }
@@ -348,6 +351,14 @@ function _statedCompileModel(state) {
         return { compilerNeeds, logs: result.problems, timingInfo };
     }
 }
+function maybeExcludeReferences(modelDef, excludeReferences) {
+    if (!excludeReferences)
+        return modelDef;
+    return {
+        ...modelDef,
+        references: undefined,
+    };
+}
 function wrapResponse(response, defaultURL) {
     const logs = response.logs ? (0, util_1.mapLogs)(response.logs, defaultURL) : undefined;
     if (response.compilerNeeds) {
@@ -375,10 +386,6 @@ function wrapResponse(response, defaultURL) {
         };
     }
 }
-function _compileModel(modelURL, compilerNeeds, extendURL, state) {
-    state !== null && state !== void 0 ? state : (state = _newCompileModelState(modelURL, compilerNeeds, extendURL));
-    return _statedCompileModel(state);
-}
 function compileModel(request, state) {
     state !== null && state !== void 0 ? state : (state = newCompileModelState(request));
     return statedCompileModel(state);
@@ -421,10 +428,13 @@ function hasErrors(log) {
     return (_a = log === null || log === void 0 ? void 0 : log.some(m => m.severity === 'error')) !== null && _a !== void 0 ? _a : false;
 }
 function newCompileQueryState(request) {
-    var _a, _b;
-    const queryMalloy = Malloy.queryToMalloy(request.query);
+    var _a, _b, _c;
+    const queryMalloy = (_a = request.query_malloy) !== null && _a !== void 0 ? _a : (request.query ? Malloy.queryToMalloy(request.query) : undefined);
+    if (queryMalloy === undefined) {
+        throw new Error('Expected either query or query_malloy');
+    }
     const needs = {
-        ...((_a = request.compiler_needs) !== null && _a !== void 0 ? _a : {}),
+        ...((_b = request.compiler_needs) !== null && _b !== void 0 ? _b : {}),
     };
     const queryURL = 'internal://query.malloy';
     needs.files = [
@@ -432,10 +442,10 @@ function newCompileQueryState(request) {
             url: queryURL,
             contents: queryMalloy,
         },
-        ...((_b = needs.files) !== null && _b !== void 0 ? _b : []),
+        ...((_c = needs.files) !== null && _c !== void 0 ? _c : []),
     ];
     return {
-        ..._newCompileModelState(queryURL, needs, request.model_url),
+        ..._newCompileModelState(queryURL, needs, undefined, request.model_url, request.exclude_references),
         defaultRowLimit: request.default_row_limit,
     };
 }

package/dist/api/sessioned.js

@@ -242,7 +242,11 @@ class SessionManager {
         }
     }
     compileQuery(request, options) {
-        const queryString = Malloy.queryToMalloy(request.query);
+        var _a;
+        const queryString = (_a = request.query_malloy) !== null && _a !== void 0 ? _a : (request.query ? Malloy.queryToMalloy(request.query) : undefined);
+        if (queryString === undefined) {
+            throw new Error('Expected query_malloy or query');
+        }
         const sessionInfo = {
             type: 'compile_query',
             modelURL: request.model_url,

package/dist/dialect/functions/util.js

@@ -233,9 +233,12 @@ function expandReturnTypeBlueprint(blueprint) {
     else if ('sql_native' in blueprint) {
         return anyExprType({ type: 'sql native', rawType: blueprint.sql_native });
     }
-    else {
+    else if ('calculation' in blueprint) {
         return minAnalytic(expandTypeDescElementBlueprint(blueprint.calculation, false));
     }
+    else {
+        throw new Error('Invalid function blueprint');
+    }
 }
 function isTypeDescBlueprint(blueprint) {
     return (typeof blueprint === 'string' ||
@@ -291,9 +294,12 @@ function expandParamTypeBlueprint(blueprint) {
     else if ('sql_native' in blueprint) {
         return anyExprType({ type: 'sql native', rawType: blueprint.sql_native });
     }
-    else {
+    else if ('calculation' in blueprint) {
         return maxAnalytic(expandTypeDescElementBlueprint(blueprint.calculation));
     }
+    else {
+        throw new Error('Invalid function blueprint');
+    }
 }
 function expandParamTypeBlueprints(blueprints) {
     return blueprints.map(blueprint => expandParamTypeBlueprint(blueprint));

package/dist/lang/ast/error-factory.js

@@ -61,13 +61,27 @@ class ErrorFactory {
         };
     }
     static get reduceSegment() {
-        return { type: 'reduce', queryFields: [] };
+        return {
+            type: 'reduce',
+            queryFields: [],
+            outputStruct: ErrorFactory.structDef,
+            isRepeated: false,
+        };
     }
     static get projectSegment() {
-        return { type: 'project', queryFields: [] };
+        return {
+            type: 'project',
+            queryFields: [],
+            outputStruct: ErrorFactory.structDef,
+            isRepeated: true,
+        };
     }
     static get indexSegment() {
-        return { type: 'index', indexFields: [] };
+        return {
+            type: 'index',
+            indexFields: [],
+            outputStruct: ErrorFactory.structDef,
+        };
     }
 }
 exports.ErrorFactory = ErrorFactory;

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

@@ -14,6 +14,7 @@ export declare class ConstantFieldSpace implements FieldSpace {
     entry(): undefined;
     dialectName(): string;
     dialectObj(): undefined;
+    connectionName(): string;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
 }

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

@@ -55,6 +55,9 @@ class ConstantFieldSpace {
     dialectObj() {
         return undefined;
     }
+    connectionName() {
+        return '~constant-space-unknown-connection~';
+    }
     isQueryFieldSpace() {
         return false;
     }

package/dist/lang/ast/expressions/expr-props.d.ts

@@ -153,6 +153,18 @@ export declare class ExprProps extends ExpressionDef {
         morphic?: {
             [x: string]: import("../../../model/malloy_types").Expr;
         };
+    } | {
+        requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
+        type: "turtle";
+        pipeline: import("../../../model/malloy_types").PipeSegment[];
+        expressionType: import("../../../model/malloy_types").ExpressionType;
+        evalSpace: import("../../../model/malloy_types").EvalSpace;
+        fieldUsage: import("../../../model/malloy_types").FieldUsage[];
+        ungroupings?: import("../../../model/malloy_types").AggregateUngrouping[];
+        value: import("../../../model/malloy_types").Expr;
+        morphic?: {
+            [x: string]: import("../../../model/malloy_types").Expr;
+        };
     } | {
         requiresGroupBy: import("../../../model/malloy_types").RequiredGroupBy[] | undefined;
         type: "date";

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

@@ -68,7 +68,7 @@ const struct_space_field_base_1 = require("./struct-space-field-base");
 const parameter_space_1 = require("./parameter-space");
 class DynamicSpace extends static_space_1.StaticSpace {
     constructor(extending) {
-        super(structuredClone(extending), extending.dialect);
+        super({ ...extending }, extending.dialect, extending.connection);
         this.complete = false;
         this.parameters = [];
         this.newAccessModifiers = new Map();

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

@@ -1,10 +1,11 @@
-import type { IndexSegment, PipeSegment } from '../../../model/malloy_types';
+import type { IndexSegment, PipeSegment, SourceDef } from '../../../model/malloy_types';
 import { WildcardFieldReference } from '../query-items/field-references';
 import type { MalloyElement } from '../types/malloy-element';
 import { QueryOperationSpace } from './query-spaces';
 export declare class IndexFieldSpace extends QueryOperationSpace {
     readonly segmentType = "index";
     pushFields(...defs: MalloyElement[]): void;
+    structDef(): SourceDef;
     getPipeSegment(refineIndex?: PipeSegment): IndexSegment;
     addRefineFromFields(_refineThis: never): void;
     protected addWild(wild: WildcardFieldReference): void;

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

@@ -25,6 +25,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexFieldSpace = void 0;
 const composite_source_utils_1 = require("../../../model/composite_source_utils");
 const malloy_types_1 = require("../../../model/malloy_types");
+const error_factory_1 = require("../error-factory");
 const field_references_1 = require("../query-items/field-references");
 const space_field_1 = require("../types/space-field");
 const query_spaces_1 = require("./query-spaces");
@@ -48,11 +49,27 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             }
         }
     }
+    structDef() {
+        const connection = this.inputSpace().connectionName();
+        return {
+            type: 'query_result',
+            name: 'result',
+            dialect: this.dialectName(),
+            fields: [
+                { type: 'string', name: 'fieldName' },
+                { type: 'string', name: 'fieldPath' },
+                { type: 'string', name: 'fieldValue' },
+                { type: 'string', name: 'fieldType' },
+                { type: 'number', name: 'weight', numberType: 'integer' },
+            ],
+            connection,
+        };
+    }
     getPipeSegment(refineIndex) {
         var _a;
         if (refineIndex) {
             this.logError('refinement-of-index-segment', 'index query operations cannot be refined');
-            return { type: 'index', indexFields: [] };
+            return error_factory_1.ErrorFactory.indexSegment;
         }
         let fieldUsage = (0, composite_source_utils_1.emptyFieldUsage)();
         const indexFields = [];
@@ -80,7 +97,8 @@ class IndexFieldSpace extends query_spaces_1.QueryOperationSpace {
             }
         }
         this._fieldUsage = fieldUsage;
-        return { type: 'index', indexFields };
+        const outputStruct = this.structDef();
+        return { type: 'index', indexFields, outputStruct };
     }
     addRefineFromFields(_refineThis) { }
     addWild(wild) {

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

@@ -4,5 +4,5 @@ import { StructSpaceField } from './static-space';
 export declare class JoinSpaceField extends StructSpaceField {
     readonly parameterSpace: ParameterSpace;
     readonly join: Join;
-    constructor(parameterSpace: ParameterSpace, join: Join, forDialect: string);
+    constructor(parameterSpace: ParameterSpace, join: Join, forDialect: string, forConnection: string);
 }

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

@@ -25,8 +25,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.JoinSpaceField = void 0;
 const static_space_1 = require("./static-space");
 class JoinSpaceField extends static_space_1.StructSpaceField {
-    constructor(parameterSpace, join, forDialect) {
-        super(join.getStructDef(parameterSpace), forDialect);
+    constructor(parameterSpace, join, forDialect, forConnection) {
+        super(join.getStructDef(parameterSpace), forDialect, forConnection);
         this.parameterSpace = parameterSpace;
         this.join = join;
     }

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

@@ -14,6 +14,7 @@ export declare class ParameterSpace implements FieldSpace {
     lookup(symbol: FieldName[]): LookupResult;
     entries(): [string, SpaceEntry][];
     dialectName(): string;
+    connectionName(): string;
     dialectObj(): Dialect | undefined;
     isQueryFieldSpace(): this is QueryFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;

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

@@ -70,6 +70,9 @@ class ParameterSpace {
     dialectName() {
         return '~parameter-space-unknown-dialect~';
     }
+    connectionName() {
+        return '~parameter-space-unknown-connection~';
+    }
     dialectObj() {
         return undefined;
     }

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

@@ -18,4 +18,5 @@ export declare class PassthroughSpace implements FieldSpace {
     outputSpace(): import("./query-spaces").QueryOperationSpace;
     inputSpace(): import("../types/field-space").SourceFieldSpace;
     accessProtectionLevel(): AccessModifierLabel;
+    connectionName(): string;
 }

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

@@ -51,6 +51,9 @@ class PassthroughSpace {
     accessProtectionLevel() {
         return this.realFS.accessProtectionLevel();
     }
+    connectionName() {
+        return this.realFS.connectionName();
+    }
 }
 exports.PassthroughSpace = PassthroughSpace;
 //# sourceMappingURL=passthrough-space.js.map

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

@@ -27,4 +27,5 @@ export declare class QueryInputSpace extends RefinedSpace implements QueryFieldS
     outputSpace(): QueryOperationSpace;
     inputSpace(): this;
     accessProtectionLevel(): AccessModifierLabel;
+    isQueryOutputSpace(): boolean;
 }

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

@@ -59,6 +59,9 @@ class QueryInputSpace extends refined_space_1.RefinedSpace {
     accessProtectionLevel() {
         return this._accessProtectionLevel;
     }
+    isQueryOutputSpace() {
+        return false;
+    }
 }
 exports.QueryInputSpace = QueryInputSpace;
 //# sourceMappingURL=query-input-space.js.map

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

@@ -9,6 +9,10 @@ import type { LookupResult } from '../types/lookup-result';
 import { QueryInputSpace } from './query-input-space';
 import type { SpaceEntry } from '../types/space-entry';
 import type { LogMessageOptions, MessageCode, MessageParameterType } from '../../parse-log';
+type TranslatedQueryField = {
+    queryFieldDef: model.QueryFieldDef;
+    typeDesc: model.TypeDesc;
+};
 /**
  * The output space of a query operation. It is not named "QueryOutputSpace"
  * because this is the namespace of the Query which is a layer of an output and
@@ -48,21 +52,29 @@ export declare abstract class QueryOperationSpace extends RefinedSpace implement
     accessProtectionLevel(): model.AccessModifierLabel;
     inputSpace(): QueryInputSpace;
     outputSpace(): QueryOperationSpace;
+    isQueryOutputSpace(): boolean;
     protected addWild(wild: WildcardFieldReference): void;
     protected addValidatedCompositeFieldUserFromEntry(name: string, entry: SpaceEntry): void;
     addFieldUserFromFilter(filter: model.FilterCondition): void;
     newEntry(name: string, logTo: MalloyElement, entry: SpaceEntry): void;
+    isQueryFieldSpace(): this is QueryFieldSpace;
 }
 export declare abstract class QuerySpace extends QueryOperationSpace {
     addRefineFromFields(refineThis: model.PipeSegment): void;
     pushFields(...defs: MalloyElement[]): void;
     canContain(_typeDescResult: model.TypeDesc | undefined): boolean;
     protected queryFieldDefs(): model.QueryFieldDef[];
+    protected getOutputFieldDef(queryFieldDef: model.QueryFieldDef, typeDesc: model.TypeDesc): model.FieldDef;
+    protected getPrimaryKey(fields: TranslatedQueryField[]): string | undefined;
+    structDef(): model.SourceDef;
+    translatedQueryFields: TranslatedQueryField[] | undefined;
+    protected translateQueryFields(): TranslatedQueryField[];
     getQuerySegment(rf: model.QuerySegment | undefined): model.QuerySegment;
+    protected isRepeated(): boolean;
     getPipeSegment(refineFrom: model.QuerySegment | undefined): model.PipeSegment;
     lookup(path: FieldName[]): LookupResult;
-    isQueryFieldSpace(): this is QueryFieldSpace;
 }
 export declare class ReduceFieldSpace extends QuerySpace {
     readonly segmentType = "reduce";
 }
+export {};