@malloydata/malloy 0.0.28-dev230314211807 → 0.0.28-dev230320190215

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

@@ -38,7 +38,7 @@ class DefineQuery extends malloy_element_1.MalloyElement {
             name: this.name,
             location: this.location,
         };
-        const exported = false;
+        const exported = true;
         doc.setEntry(this.name, { entry, exported });
         return undefined;
     }

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

@@ -56,12 +56,8 @@ class ImportStatement extends malloy_element_1.MalloyElement {
                 if (childNeeds) {
                     return childNeeds;
                 }
-                const importStructs = trans.getChildExports(this.fullURL);
-                for (const importing in importStructs) {
-                    doc.setEntry(importing, {
-                        entry: importStructs[importing],
-                        exported: false,
-                    });
+                for (const [importing, entry] of Object.entries(trans.getChildExports(this.fullURL))) {
+                    doc.setEntry(importing, { entry, exported: false });
                 }
             }
             else if (src.status === 'error') {

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

@@ -6,6 +6,6 @@ export declare class ExistingQuery extends PipelineDesc {
     _head?: ModelEntryReference;
     set head(head: ModelEntryReference | undefined);
     get head(): ModelEntryReference | undefined;
-    queryComp(): QueryComp;
+    queryComp(isRefOk: boolean): QueryComp;
     query(): Query;
 }

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

@@ -35,7 +35,7 @@ class ExistingQuery extends pipeline_desc_1.PipelineDesc {
     get head() {
         return this._head;
     }
-    queryComp() {
+    queryComp(isRefOk) {
         if (!this.head) {
             throw this.internalError("can't make query from nameless query");
         }
@@ -66,13 +66,13 @@ class ExistingQuery extends pipeline_desc_1.PipelineDesc {
         const query = {
             type: 'query',
             ...destPipe,
-            structRef: queryHead.structRef(),
+            structRef: isRefOk ? queryHead.structRef() : queryHead.structDef(),
             location: this.location,
         };
         return { outputStruct: appended.structDef, query };
     }
     query() {
-        return this.queryComp().query;
+        return this.queryComp(true).query;
     }
 }
 exports.ExistingQuery = ExistingQuery;

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

@@ -5,6 +5,6 @@ import { TurtleHeadedPipe } from '../types/turtle-headed-pipe';
 export declare class FullQuery extends TurtleHeadedPipe {
     readonly explore: Source;
     constructor(explore: Source);
-    queryComp(): QueryComp;
+    queryComp(isRefOk: boolean): QueryComp;
     query(): Query;
 }

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

@@ -32,8 +32,10 @@ class FullQuery extends turtle_headed_pipe_1.TurtleHeadedPipe {
         super({ explore: explore });
         this.explore = explore;
     }
-    queryComp() {
-        const structRef = this.explore.structRef();
+    queryComp(isRefOk) {
+        const structRef = isRefOk
+            ? this.explore.structRef()
+            : this.explore.structDef();
         const destQuery = {
             type: 'query',
             structRef,
@@ -78,7 +80,7 @@ class FullQuery extends turtle_headed_pipe_1.TurtleHeadedPipe {
         return { outputStruct: appended.structDef, query: destQuery };
     }
     query() {
-        return this.queryComp().query;
+        return this.queryComp(true).query;
     }
 }
 exports.FullQuery = FullQuery;

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

@@ -31,7 +31,7 @@ class QuerySource extends source_1.Source {
         this.elementType = 'querySource';
     }
     structDef() {
-        const comp = this.query.queryComp();
+        const comp = this.query.queryComp(false);
         const queryStruct = comp.outputStruct;
         queryStruct.structSource = { type: 'query', query: comp.query };
         return queryStruct;

package/dist/lang/parse-malloy.d.ts

@@ -1,6 +1,6 @@
 import { CodePointCharStream, CommonTokenStream, ParserRuleContext, Token } from 'antlr4ts';
 import { ParseTree } from 'antlr4ts/tree';
-import { DocumentLocation, DocumentPosition, DocumentRange, DocumentReference, ModelDef, NamedStructDefs, Query, SQLBlockStructDef, StructDef } from '../model/malloy_types';
+import { DocumentLocation, DocumentPosition, DocumentRange, DocumentReference, ModelDef, NamedModelObject, Query, SQLBlockStructDef, StructDef } from '../model/malloy_types';
 import { MessageLog } from './parse-log';
 import { Zone, ZoneData } from './zone';
 import { ReferenceList } from './reference-list';
@@ -125,7 +125,7 @@ export declare abstract class MalloyTranslation {
     getLineMap(url: string): string[] | undefined;
     prettyErrors(): string;
     childRequest(importURL: string): ModelDataRequest;
-    getChildExports(importURL: string): NamedStructDefs;
+    getChildExports(importURL: string): Record<string, NamedModelObject>;
     private finalAnswer?;
     translate(extendingModel?: ModelDef): TranslateResponse;
     metadata(): MetadataResponse;
@@ -142,6 +142,10 @@ export declare abstract class MalloyTranslation {
     rangeFromTokens(startToken: Token, stopToken: Token): DocumentRange;
     rangeFromToken(token: Token): DocumentRange;
 }
+export declare class MalloyChildTranslator extends MalloyTranslation {
+    readonly root: MalloyTranslator;
+    constructor(rootURL: string, root: MalloyTranslator);
+}
 /**
  * The main interface to Malloy tranlsation. It has a call pattern
  * similar to a server. Once a translator is instantiated

package/dist/lang/parse-malloy.js

@@ -45,7 +45,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MalloyTranslator = exports.MalloyTranslation = void 0;
+exports.MalloyTranslator = exports.MalloyChildTranslator = exports.MalloyTranslation = void 0;
 const antlr4ts_1 = require("antlr4ts");
 const MalloyLexer_1 = require("./lib/Malloy/MalloyLexer");
 const MalloyParser_1 = require("./lib/Malloy/MalloyParser");
@@ -612,7 +612,7 @@ class MalloyTranslation {
             if (did.translated) {
                 for (const fromChild of child.modelDef.exports) {
                     const modelEntry = child.modelDef.contents[fromChild];
-                    if (modelEntry.type === 'struct') {
+                    if (modelEntry.type === 'struct' || modelEntry.type === 'query') {
                         exports[fromChild] = modelEntry;
                     }
                 }
@@ -695,6 +695,7 @@ class MalloyChildTranslator extends MalloyTranslation {
         this.root = root;
     }
 }
+exports.MalloyChildTranslator = MalloyChildTranslator;
 /**
  * The main interface to Malloy tranlsation. It has a call pattern
  * similar to a server. Once a translator is instantiated

package/dist/lang/test/imports.spec.d.ts

@@ -0,0 +1 @@
+import './parse-expects';

package/dist/lang/test/imports.spec.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * 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.
+ */
+require("./parse-expects");
+const test_translator_1 = require("./test-translator");
+describe('import:', () => {
+    test('simple source', () => {
+        const docParse = new test_translator_1.TestTranslator('import "child"');
+        const xr = docParse.unresolved();
+        expect(docParse).toBeErrorless();
+        expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
+        docParse.update({
+            urls: { 'internal://test/langtests/child': 'source: aa is a' },
+        });
+        expect(docParse).modelCompiled();
+        const aa = docParse.getSourceDef('aa');
+        expect(aa).toBeDefined();
+    });
+    test('simple query', () => {
+        const docParse = new test_translator_1.TestTranslator('import "child"');
+        const xr = docParse.unresolved();
+        expect(docParse).toBeErrorless();
+        expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
+        docParse.update({
+            urls: {
+                'internal://test/langtests/child': 'query: aq is a->{ project: * }',
+            },
+        });
+        expect(docParse).modelCompiled();
+        const aq = docParse.getQuery('aq');
+        expect(aq).toBeDefined();
+    });
+    test('query based source with named structref', () => {
+        const docParse = new test_translator_1.TestTranslator(`
+import "child"
+source: newSrc is a {
+  join_one: b is botProjQSrc on b.astr = astr
+}
+`);
+        const xr = docParse.unresolved();
+        expect(docParse).toBeErrorless();
+        expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
+        docParse.update({
+            urls: {
+                'internal://test/langtests/child': `
+source: bottomSrc is a
+query: botProjQ is bottomSrc -> { project: * }
+source: botProjQSrc is from(->botProjQ)
+`,
+            },
+        });
+        expect(docParse).modelCompiled();
+        const newSrc = docParse.getSourceDef('newSrc');
+        const f = newSrc === null || newSrc === void 0 ? void 0 : newSrc.fields.find(f => f.name === 'b');
+        expect(f === null || f === void 0 ? void 0 : f.type).toBe('struct');
+        if ((f === null || f === void 0 ? void 0 : f.type) === 'struct') {
+            const ss = f.structSource;
+            expect(ss.type).toBe('query');
+            if (ss.type === 'query') {
+                expect(typeof ss.query.structRef).not.toBe('string');
+            }
+        }
+    });
+    test('missing import', () => {
+        const docParse = new test_translator_1.TestTranslator('import "child"');
+        const xr = docParse.unresolved();
+        expect(docParse).toBeErrorless();
+        expect(xr).toEqual({ urls: ['internal://test/langtests/child'] });
+        const reportedError = 'ENOWAY: No way to find your child';
+        docParse.update({
+            errors: {
+                urls: { 'internal://test/langtests/child': reportedError },
+            },
+        });
+        docParse.translate();
+        expect(docParse).not.toBeErrorless();
+        expect(docParse.prettyErrors()).toContain(reportedError);
+    });
+    test('chained imports', () => {
+        const docParse = new test_translator_1.TestTranslator('import "child"');
+        docParse.update({
+            urls: { 'internal://test/langtests/child': 'import "grandChild"' },
+        });
+        const xr = docParse.unresolved();
+        expect(docParse).toBeErrorless();
+        expect(xr).toEqual({ urls: ['internal://test/langtests/grandChild'] });
+    });
+    test('relative imports', () => {
+        const docParse = new test_translator_1.TestTranslator('import "../parent.malloy"');
+        expect(docParse).modelParsed();
+        const xr = docParse.unresolved();
+        expect(xr).toEqual({ urls: ['internal://test/parent.malloy'] });
+        docParse.update({
+            urls: {
+                'internal://test/parent.malloy': "source: aa is table('aTable')",
+            },
+        });
+        expect(docParse).modelCompiled();
+    });
+    test('relative imports with errors', () => {
+        const docParse = new test_translator_1.TestTranslator('import "../parent.malloy"');
+        expect(docParse).modelParsed();
+        const xr = docParse.unresolved();
+        expect(xr).toEqual({ urls: ['internal://test/parent.malloy'] });
+        docParse.update({
+            urls: {
+                'internal://test/parent.malloy': `
+          source: aa is table('aTable') {
+            dimension: astr is 'not legal beause astr exists'
+          }`,
+            },
+        });
+        expect(docParse).compileToFailWith("Cannot redefine 'astr'");
+    });
+    test('source references expanded when not exported', () => {
+        const srcFiles = {
+            'internal://test/langtests/middle': `
+        import "bottom"
+        source: midSrc is from(bottomSrc -> { group_by: astr })
+      `,
+            'internal://test/langtests/bottom': "source: bottomSrc is table('aTable')",
+        };
+        const fullModel = new test_translator_1.TestTranslator(`
+      import "middle"
+    `);
+        fullModel.update({ urls: srcFiles });
+        expect(fullModel).modelCompiled();
+        const ms = fullModel.getSourceDef('midSrc');
+        expect(ms).toBeDefined();
+        if (ms) {
+            expect(ms.structSource.type).toBe('query');
+            if (ms.structSource.type === 'query') {
+                const qs = ms.structSource.query.structRef;
+                expect(typeof qs).not.toBe('string');
+            }
+        }
+    });
+});
+//# sourceMappingURL=imports.spec.js.map

package/dist/lang/test/parse-expects.d.ts

@@ -0,0 +1,14 @@
+import { DocumentLocation } from '../../model';
+declare global {
+    namespace jest {
+        interface Matchers<R> {
+            modelParsed(): R;
+            toBeErrorless(): R;
+            toCompile(): R;
+            modelCompiled(): R;
+            toReturnType(tp: string): R;
+            compileToFailWith(...expectedErrors: string[]): R;
+            isLocationIn(at: DocumentLocation, txt: string): R;
+        }
+    }
+}

package/dist/lang/test/parse-expects.js

@@ -0,0 +1,232 @@
+"use strict";
+/* eslint-disable no-console */
+/*
+ * 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 });
+const test_translator_1 = require("./test-translator");
+const util_1 = require("util");
+function checkForErrors(trans) {
+    if (trans.logger === undefined) {
+        throw new Error('JESTERY BROKEN, CANT FIND ERORR LOG');
+    }
+    if (trans.logger.hasErrors()) {
+        return {
+            message: () => `Translation Errors:\n${trans.prettyErrors()}`,
+            pass: false,
+        };
+    }
+    return {
+        message: () => 'Unexpected error free translation',
+        pass: true,
+    };
+}
+function prettyNeeds(response) {
+    let needString = '';
+    if (response.tables) {
+        needString += 'Tables:\n';
+        response.tables.forEach(table => (needString += `  - ${table}`));
+    }
+    if (response.compileSQL) {
+        needString += `Compile SQL: ${response.compileSQL.name}`;
+    }
+    if (response.urls) {
+        needString += 'URLs:\n';
+        response.urls.forEach(url => (needString += `  - ${url}`));
+    }
+    return needString;
+}
+function checkForNeededs(trans) {
+    const response = trans.translateStep.step(trans);
+    if (!response.final) {
+        return {
+            message: () => `Translation is not complete, needs:\n${prettyNeeds(response)}`,
+            pass: false,
+        };
+    }
+    return {
+        message: () => 'Unexpected complete translation',
+        pass: true,
+    };
+}
+function highlightError(dl, txt) {
+    if (dl === undefined) {
+        return '~Location Undefined~';
+    }
+    const { start, end } = dl.range;
+    const output = [
+        `${start.line}:${start.character}-${end.line}:${end.character}`,
+    ];
+    let errStart = start.character;
+    const doc = txt.split('\n');
+    for (let line = start.line; line <= end.line; line += 1) {
+        const lineText = doc[line];
+        const lineStr = `     ${line}`.slice(-5);
+        output.push(`${lineStr}| ${lineText}`);
+        const upToError = '     | ' + ' '.repeat(errStart);
+        let errLen = end.character - errStart;
+        if (line < end.line) {
+            errLen = lineText.length - errStart;
+            errStart = 0;
+        }
+        output.push(upToError + '-'.repeat(errLen));
+    }
+    return output.join('\n');
+}
+expect.extend({
+    toCompile: function (s) {
+        const x = new test_translator_1.TestTranslator(s);
+        x.compile();
+        const errorCheck = checkForErrors(x);
+        if (!errorCheck.pass) {
+            return errorCheck;
+        }
+        x.translate();
+        return checkForNeededs(x);
+    },
+    modelParsed: function (x) {
+        x.compile();
+        return checkForErrors(x);
+    },
+    modelCompiled: function (x) {
+        x.compile();
+        const errorCheck = checkForErrors(x);
+        if (!errorCheck.pass) {
+            return errorCheck;
+        }
+        x.translate();
+        return checkForNeededs(x);
+    },
+    toBeErrorless: function (trans) {
+        return checkForErrors(trans);
+    },
+    toReturnType: function (functionCall, returnType) {
+        const exprModel = new test_translator_1.TestTranslator(`explore: x is a { dimension: d is ${functionCall} }`);
+        expect(exprModel).modelCompiled();
+        const x = exprModel.getSourceDef('x');
+        expect(x).toBeDefined();
+        if (x) {
+            const d = x.fields.find(f => f.name === 'd');
+            expect(d === null || d === void 0 ? void 0 : d.type).toBe(returnType);
+        }
+        return {
+            pass: true,
+            message: () => '',
+        };
+    },
+    compileToFailWith: function (s, ...msgs) {
+        var _a;
+        let emsg = 'Compile Error expectation not met\nExpected error';
+        let mSrc;
+        const qmsgs = msgs.map(s => `error '${s}'`);
+        if (msgs.length === 1) {
+            emsg += ` ${qmsgs[0]}`;
+        }
+        else {
+            emsg += `s [\n${qmsgs.join('\n')}\n]`;
+        }
+        let m;
+        let src;
+        if (s instanceof test_translator_1.TestTranslator) {
+            m = s;
+            src = m.testSrc;
+        }
+        else {
+            if (typeof s === 'string') {
+                src = s;
+            }
+            else {
+                src = s.code;
+                mSrc = s;
+            }
+            m = new test_translator_1.TestTranslator(src);
+        }
+        emsg += `\nSource:\n${src}`;
+        const t = m.translate();
+        if (t.translated) {
+            return { pass: false, message: () => emsg };
+        }
+        else if (t.errors === undefined) {
+            return {
+                pass: false,
+                message: () => 'TEST ERROR, not all objects resolved in source\n' +
+                    (0, test_translator_1.pretty)(t) +
+                    '\n' +
+                    emsg,
+            };
+        }
+        else {
+            const explain = [];
+            const errList = m.errors().errors;
+            let i;
+            for (i = 0; i < msgs.length && errList[i]; i += 1) {
+                const msg = msgs[i];
+                const err = errList[i];
+                if (msg !== err.message) {
+                    explain.push(`Expected: ${msg}\nGot: ${err.message}`);
+                }
+                else {
+                    if (mSrc === null || mSrc === void 0 ? void 0 : mSrc.locations[i]) {
+                        const have = (_a = err.at) === null || _a === void 0 ? void 0 : _a.range;
+                        const want = mSrc.locations[i].range;
+                        if (!this.equals(have, want)) {
+                            explain.push(`Expected '${msg}' at location: ${(0, util_1.inspect)(want)}\n` +
+                                `Actual location: ${(0, util_1.inspect)(have)}`);
+                        }
+                    }
+                }
+            }
+            if (i !== msgs.length) {
+                explain.push(...msgs.slice(i).map(m => `Missing: ${m}`));
+            }
+            if (i !== errList.length) {
+                explain.push(...errList.slice(i).map(m => `Unexpected Error: ${m.message}`));
+            }
+            if (explain.length === 0) {
+                return {
+                    pass: true,
+                    message: () => `All expected errors found: ${(0, test_translator_1.pretty)(msgs)}`,
+                };
+            }
+            return {
+                pass: false,
+                message: () => `Compiler did not generated expected errors\n${explain.join('\n')}`,
+            };
+        }
+    },
+    isLocationIn: function (checkAt, at, text) {
+        if (this.equals(at, checkAt)) {
+            return {
+                pass: true,
+                message: () => 'Locations match',
+            };
+        }
+        const errMsg = 'Locations do not match\n' +
+            `Expected: ${highlightError(at, text)}\n` +
+            `Received: ${highlightError(checkAt, text)}\n`;
+        return {
+            pass: false,
+            message: () => errMsg,
+        };
+    },
+});
+//# sourceMappingURL=parse-expects.js.map

package/dist/lang/test/parse.spec.d.ts

@@ -1,14 +1 @@
-import { DocumentLocation } from '../../model';
-declare global {
-    namespace jest {
-        interface Matchers<R> {
-            modelParsed(): R;
-            toBeErrorless(): R;
-            toCompile(): R;
-            modelCompiled(): R;
-            toReturnType(tp: string): R;
-            compileToFailWith(...expectedErrors: string[]): R;
-            isLocationIn(at: DocumentLocation, txt: string): R;
-        }
-    }
-}
+import './parse-expects';