@malloydata/malloy 0.0.237-dev250225015031 → 0.0.237-dev250225144145

package/dist/model/malloy_query.d.ts

@@ -4,7 +4,7 @@ import { Connection } from '../connection/types';
 import { AndChain } from './utils';
 import { QueryInfo } from '../dialect/dialect';
 import { EventStream } from '../runtime_types';
-import { Tag } from '../tags';
+import { Tag } from '@malloydata/malloy-tag';
 interface TurtleDefPlus extends TurtleDef, Filtered {
 }
 /** Parent from QueryStruct. */
@@ -225,6 +225,8 @@ declare class JoinInstance {
 export declare class Segment {
     static nextStructDef(structDef: SourceDef, segment: PipeSegment): QueryResultDef;
 }
+export declare function getResultStructDefForView(source: SourceDef, view: TurtleDef): SourceDef;
+export declare function getResultStructDefForQuery(model: ModelDef, query: Query): SourceDef;
 type StageGroupMaping = {
     fromGroup: number;
     toGroup: number;

package/dist/model/malloy_query.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueryModel = exports.Segment = void 0;
+exports.QueryModel = exports.getResultStructDefForQuery = exports.getResultStructDefForView = exports.Segment = void 0;
 /*
  * Copyright 2023 Google LLC
  *
@@ -29,7 +29,7 @@ const standardsql_1 = require("../dialect/standardsql/standardsql");
 const malloy_types_1 = require("./malloy_types");
 const utils_1 = require("./utils");
 const utils_2 = require("./materialization/utils");
-const tags_1 = require("../tags");
+const annotation_1 = require("../annotation");
 function pathToCol(path) {
     return path.map(el => encodeURIComponent(el)).join('/');
 }
@@ -1564,6 +1564,21 @@ class Segment {
     }
 }
 exports.Segment = Segment;
+function getResultStructDefForView(source, view) {
+    const qs = new QueryStruct(source, undefined, {
+        model: new QueryModel(undefined),
+    }, {});
+    const queryQueryQuery = QueryQuery.makeQuery(view, qs, new StageWriter(true, undefined), // stage write indicates we want to get a result.
+    false);
+    return queryQueryQuery.getResultStructDef();
+}
+exports.getResultStructDefForView = getResultStructDefForView;
+function getResultStructDefForQuery(model, query) {
+    const queryModel = new QueryModel(model);
+    const compiled = queryModel.compileQuery(query);
+    return compiled.structs[compiled.structs.length - 1];
+}
+exports.getResultStructDefForQuery = getResultStructDefForQuery;
 /** Query builder object. */
 class QueryQuery extends QueryField {
     constructor(fieldDef, parent, stageWriter, isJoinedSubquery) {
@@ -3087,7 +3102,7 @@ class QueryStruct {
     modelCompilerFlags() {
         if (this._modelTag === undefined) {
             const annotation = this.structDef.modelAnnotation;
-            const { tag } = tags_1.Tag.annotationToTag(annotation, { prefix: /^##!\s*/ });
+            const { tag } = (0, annotation_1.annotationToTag)(annotation, { prefix: /^##!\s*/ });
             this._modelTag = tag;
         }
         return this._modelTag;

package/dist/model/materialization/utils.js

@@ -7,14 +7,14 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildQueryMaterializationSpec = exports.shouldMaterialize = void 0;
-const tags_1 = require("../../tags");
 const utils_1 = require("../utils");
+const annotation_1 = require("../../annotation");
 function shouldMaterialize(annotation) {
     const clonedAnnotation = structuredClone(annotation);
     if (clonedAnnotation) {
         clonedAnnotation.inherits = undefined;
     }
-    const sourceTag = tags_1.Tag.annotationToTag(clonedAnnotation).tag;
+    const sourceTag = (0, annotation_1.annotationToTag)(clonedAnnotation).tag;
     return sourceTag.has('materialize');
 }
 exports.shouldMaterialize = shouldMaterialize;

package/dist/to_stable.d.ts

@@ -0,0 +1,3 @@
+import * as Malloy from '@malloydata/malloy-interfaces';
+import { ModelDef } from './model';
+export declare function modelDefToModelInfo(modelDef: ModelDef): Malloy.ModelInfo;

package/dist/to_stable.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modelDefToModelInfo = void 0;
+const model_1 = require("./model");
+const malloy_query_1 = require("./model/malloy_query");
+function modelDefToModelInfo(modelDef) {
+    const modelInfo = {
+        entries: [],
+        anonymous_queries: [],
+    };
+    for (const [name, entry] of Object.entries(modelDef.contents)) {
+        if (!modelDef.exports.includes(name))
+            continue;
+        if ((0, model_1.isSourceDef)(entry)) {
+            const sourceInfo = {
+                kind: 'source',
+                name,
+                schema: {
+                    fields: convertFieldInfos(entry, entry.fields),
+                },
+            };
+            modelInfo.entries.push(sourceInfo);
+        }
+        else if (entry.type === 'query') {
+            const outputStruct = (0, malloy_query_1.getResultStructDefForQuery)(modelDef, entry);
+            const queryInfo = {
+                kind: 'source',
+                name,
+                schema: {
+                    fields: convertFieldInfos(outputStruct, outputStruct.fields),
+                },
+            };
+            modelInfo.entries.push(queryInfo);
+        }
+    }
+    return modelInfo;
+}
+exports.modelDefToModelInfo = modelDefToModelInfo;
+function convertFieldInfos(source, fields) {
+    var _a, _b, _c;
+    const result = [];
+    for (const field of fields) {
+        if ((0, model_1.isTurtle)(field)) {
+            const outputStruct = (0, malloy_query_1.getResultStructDefForView)(source, field);
+            const fieldInfo = {
+                kind: 'view',
+                name: (_a = field.as) !== null && _a !== void 0 ? _a : field.name,
+                schema: { fields: convertFieldInfos(outputStruct, outputStruct.fields) },
+            };
+            result.push(fieldInfo);
+        }
+        else if ((0, model_1.isAtomic)(field)) {
+            const aggregate = (0, model_1.expressionIsAggregate)(field.expressionType);
+            const scalar = (0, model_1.expressionIsScalar)(field.expressionType);
+            if (!aggregate && !scalar)
+                continue;
+            if (field.type === 'error')
+                continue;
+            const fieldInfo = {
+                kind: aggregate ? 'measure' : 'dimension',
+                name: (_b = field.as) !== null && _b !== void 0 ? _b : field.name,
+                type: typeDefToType(field),
+            };
+            result.push(fieldInfo);
+        }
+        else if ((0, model_1.isJoinedSource)(field)) {
+            const fieldInfo = {
+                kind: 'join',
+                name: (_c = field.as) !== null && _c !== void 0 ? _c : field.name,
+                schema: {
+                    fields: convertFieldInfos(field, field.fields),
+                },
+                relationship: convertJoinType(field.join),
+            };
+            result.push(fieldInfo);
+        }
+    }
+    return result;
+}
+function typeDefToType(field) {
+    if ((0, model_1.isLeafAtomic)(field)) {
+        switch (field.type) {
+            case 'string':
+                return { kind: 'string_type' };
+            case 'number':
+                return {
+                    kind: 'number_type',
+                    subtype: field.numberType === 'float'
+                        ? 'decimal'
+                        : field.numberType === 'integer'
+                            ? 'integer'
+                            : undefined,
+                };
+            case 'boolean':
+                return { kind: 'boolean_type' };
+            case 'date':
+                return {
+                    kind: 'date_type',
+                    timeframe: convertDateTimeframe(field.timeframe),
+                };
+            case 'timestamp':
+                return {
+                    kind: 'timestamp_type',
+                    timeframe: convertTimestampTimeframe(field.timeframe),
+                };
+            case 'json':
+                return { kind: 'json_type' };
+            case 'sql native':
+                return {
+                    kind: 'sql_native_type',
+                    sql_type: field.rawType,
+                };
+            case 'error':
+                throw new Error('Error type is not supported in stable interface');
+        }
+    }
+    else if ((0, model_1.isRepeatedRecord)(field)) {
+        return {
+            kind: 'array_type',
+            element_type: convertRecordType(field),
+        };
+    }
+    else if (field.type === 'record') {
+        return convertRecordType(field);
+    }
+    else if (field.type === 'array') {
+        return {
+            kind: 'array_type',
+            element_type: typeDefToType(field.elementTypeDef),
+        };
+    }
+    throw new Error('Unexpected field type');
+}
+function convertRecordType(field) {
+    return {
+        kind: 'record_type',
+        fields: field.fields.map(f => {
+            if ((0, model_1.isAtomic)(f)) {
+                return {
+                    name: f.name,
+                    type: typeDefToType(f),
+                };
+            }
+            else {
+                throw new Error('Expected record type to not have a table as its child');
+            }
+        }),
+    };
+}
+function convertDateTimeframe(timeframe) {
+    switch (timeframe) {
+        case undefined:
+            return undefined;
+        case 'day':
+        case 'week':
+        case 'month':
+        case 'year':
+        case 'quarter':
+            return timeframe;
+        default:
+            throw new Error('Invalid date timeframe');
+    }
+}
+function convertTimestampTimeframe(timeframe) {
+    return timeframe;
+}
+function convertJoinType(type) {
+    return type;
+}
+//# sourceMappingURL=to_stable.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.237-dev250225015031",
+  "version": "0.0.237-dev250225144145",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -41,6 +41,8 @@
     "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-interfaces": "^0.0.237-dev250225144145",
+    "@malloydata/malloy-tag": "^0.0.237-dev250225144145",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jest-diff": "^29.6.2",

package/dist/lang/lib/Malloy/MalloyTagLexer.d.ts

@@ -1,42 +0,0 @@
-import { ATN } from "antlr4ts/atn/ATN";
-import { CharStream } from "antlr4ts/CharStream";
-import { Lexer } from "antlr4ts/Lexer";
-import { Vocabulary } from "antlr4ts/Vocabulary";
-export declare class MalloyTagLexer extends Lexer {
-    static readonly MINUS_DOTTY = 1;
-    static readonly DOTTY = 2;
-    static readonly DOT = 3;
-    static readonly MINUS = 4;
-    static readonly EQ = 5;
-    static readonly RF_BEG = 6;
-    static readonly RF_END = 7;
-    static readonly PR_BEG = 8;
-    static readonly PR_END = 9;
-    static readonly AR_BEG = 10;
-    static readonly COMMA = 11;
-    static readonly AR_END = 12;
-    static readonly SQ_STRING = 13;
-    static readonly DQ_STRING = 14;
-    static readonly BQ_STRING = 15;
-    static readonly NUMERIC_LITERAL = 16;
-    static readonly BARE_STRING = 17;
-    static readonly COMMENT = 18;
-    static readonly WHITE_SPACE = 19;
-    static readonly UNEXPECTED_CHAR = 20;
-    static readonly channelNames: string[];
-    static readonly modeNames: string[];
-    static readonly ruleNames: string[];
-    private static readonly _LITERAL_NAMES;
-    private static readonly _SYMBOLIC_NAMES;
-    static readonly VOCABULARY: Vocabulary;
-    get vocabulary(): Vocabulary;
-    constructor(input: CharStream);
-    get grammarFileName(): string;
-    get ruleNames(): string[];
-    get serializedATN(): string;
-    get channelNames(): string[];
-    get modeNames(): string[];
-    static readonly _serializedATN: string;
-    static __ATN: ATN;
-    static get _ATN(): ATN;
-}