@malloydata/malloy 0.0.275 → 0.0.276

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

@@ -171,7 +171,7 @@ class QueryOperationSpace extends refined_space_1.RefinedSpace {
         var _a;
         const reference = joinPath.map(n => new field_space_1.FieldName(n));
         this.astEl.has({ reference });
-        const lookup = this.exprSpace.lookup(reference);
+        const lookup = this.exprSpace.lookup(reference, 'private');
         // Should always be found...
         if (lookup.found && lookup.found instanceof struct_space_field_base_1.StructSpaceFieldBase) {
             return (0, composite_source_utils_1.joinedFieldUsage)(joinPath.slice(0, -1), (_a = lookup.found.fieldDef().onFieldUsage) !== null && _a !== void 0 ? _a : (0, composite_source_utils_1.emptyFieldUsage)());

package/dist/lang/ast/source-elements/composite-source.js

@@ -23,29 +23,68 @@ class CompositeSource extends source_1.Source {
         return this.withParameters(parameterSpace, []);
     }
     withParameters(parameterSpace, pList) {
-        const sourceDefs = this.sources.map(source => source.withParameters(parameterSpace, pList));
-        const connection = sourceDefs[0].connection;
-        const dialect = sourceDefs[0].dialect;
-        const name = 'composite_source';
-        const fields = [];
-        const fieldsByName = new Map();
-        this.sources.forEach((source, index) => {
-            var _a;
-            const sourceDef = sourceDefs[index];
-            // Check that connections all match; don't bother checking dialect, since it will
-            // match if the connection matches.
-            if (sourceDef.connection !== connection) {
-                source.logError('composite-source-connection-mismatch', `All sources in a composite source must share the same connection; connection \`${sourceDef.connection}\` differs from previous connection \`${connection}\``);
+        const sourceDefs = this.sources.map(source => {
+            return {
+                sourceDef: source.withParameters(parameterSpace, pList),
+                logTo: source,
+            };
+        });
+        return composeSources(sourceDefs, this);
+    }
+}
+exports.CompositeSource = CompositeSource;
+function composeSources(sources, compositeCodeSource) {
+    const connection = sources[0].sourceDef.connection;
+    const dialect = sources[0].sourceDef.dialect;
+    const name = 'composite_source';
+    const fieldsByName = new Map();
+    const joinsToCompose = new Map();
+    sources.forEach(source => {
+        var _a;
+        const sourceDef = source.sourceDef;
+        // Check that connections all match; don't bother checking dialect, since it will
+        // match if the connection matches.
+        if (sourceDef.connection !== connection) {
+            source.logTo.logError('composite-source-connection-mismatch', `All sources in a composite source must share the same connection; connection \`${sourceDef.connection}\` differs from previous connection \`${connection}\``);
+        }
+        for (const field of sourceDef.fields) {
+            const fieldName = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+            if (field.accessModifier === 'private') {
+                continue;
             }
-            for (const field of sourceDef.fields) {
-                if (!(0, malloy_types_1.isAtomic)(field)) {
-                    source.logWarning('composite-source-atomic-fields-only', `Only atomic fields are supported in composite sources; field \`${field.name}\` is not atomic and will be ignored`);
-                    continue;
+            /**
+             * compose(flights -> {nest: by_carrier})
+             *
+             *
+             *
+             *
+             */
+            // does not handle compose(flights -> {nest: by_carrier})
+            if ((0, malloy_types_1.isJoined)(field) && (0, malloy_types_1.isSourceDef)(field)) {
+                const existingJoins = joinsToCompose.get(fieldName);
+                if (existingJoins) {
+                    existingJoins.sources.push(field);
+                    if (field.join !== existingJoins.join) {
+                        source.logTo.logError('composite-source-connection-mismatch', `Composited joins must have the same join type; \`${field.join}\` differs from previous type \`${existingJoins.join}\``);
+                    }
+                    if (field.matrixOperation !== existingJoins.matrixOperation) {
+                        source.logTo.logError('composite-source-connection-mismatch', `Composited joins must have the same matrix operation; \`${field.matrixOperation}\` differs from previous operation \`${existingJoins.matrixOperation}\``);
+                    }
+                    if (field.accessModifier === 'internal') {
+                        existingJoins.accessModifier = 'internal';
+                    }
                 }
-                if (field.accessModifier === 'private') {
-                    continue;
+                else {
+                    joinsToCompose.set(fieldName, {
+                        sources: [field],
+                        join: field.join,
+                        matrixOperation: field.matrixOperation,
+                        accessModifier: field.accessModifier,
+                    });
                 }
-                const fieldName = (_a = field.as) !== null && _a !== void 0 ? _a : field.name;
+                // TODO ensure that there isn't also a normal field with this name...
+            }
+            else if ((0, malloy_types_1.isAtomic)(field)) {
                 const existing = fieldsByName.get(fieldName);
                 if (existing === undefined) {
                     const compositeField = {
@@ -53,32 +92,72 @@ class CompositeSource extends source_1.Source {
                         name: fieldName,
                         as: undefined,
                         e: { node: 'compositeField' },
-                        fieldUsage: [{ path: [fieldName], at: this.codeLocation }],
-                        code: this.code,
-                        location: this.codeLocation,
+                        fieldUsage: [
+                            { path: [fieldName], at: compositeCodeSource.codeLocation },
+                        ],
+                        code: compositeCodeSource.code,
+                        location: compositeCodeSource.codeLocation,
                         // A composite field's grouping may differ from slice to slice
                         requiresGroupBy: undefined,
                     };
                     fieldsByName.set(fieldName, compositeField);
-                    fields.push(compositeField);
                 }
-                else if (field.accessModifier === 'internal') {
-                    existing.accessModifier = 'internal';
+                else {
+                    if (field.accessModifier === 'internal') {
+                        existing.accessModifier = 'internal';
+                    }
+                    if (!(malloy_types_1.TD.eq(field, existing) ||
+                        // Handle the case where both fields don't have a raw type...
+                        // TODO ask MToy about this
+                        (field.type === 'sql native' &&
+                            existing.type === 'sql native' &&
+                            field.rawType === existing.rawType))) {
+                        source.logTo.logError('composite-field-type-mismatch', `field \`${field.name}\` must have the same type in all composite inputs: ${prettyType(field)} does not match ${prettyType(existing)}`);
+                    }
                 }
             }
-        });
-        return {
-            type: 'composite',
-            // TODO Use sourceRefs rather than sourceDefs when possible to avoid potential
-            // explosion of source defs...
-            sources: sourceDefs,
-            connection,
-            fields,
-            dialect,
-            name,
-            parameters: sourceDefs[0].parameters,
+            else {
+                source.logTo.logWarning('composite-source-atomic-fields-only', `Only atomic fields are supported in composite sources; field \`${field.name}\` is not atomic and will be ignored`);
+            }
+            // TODO actually typecheck the existing field against the new field...
+        }
+    });
+    for (const [joinName, sourcesInJoin] of joinsToCompose.entries()) {
+        if (fieldsByName.has(joinName)) {
+            compositeCodeSource.logError('composite-field-type-mismatch', `field \`${joinName}\` must be a join in all sources or none`);
+        }
+        const composedSource = composeSources(sourcesInJoin.sources.map(s => ({
+            sourceDef: s,
+            logTo: compositeCodeSource,
+        })), compositeCodeSource);
+        const compositeJoin = {
+            ...composedSource,
+            // We don't need to store the sources, since this is just a placeholder for typechecking
+            // the composite resolver will use the joins from the original input sources regardless.
+            sources: [],
+            join: sourcesInJoin.join,
+            name: joinName,
+            matrixOperation: sourcesInJoin.matrixOperation,
+            onExpression: undefined,
+            onCompositeFieldUsage: [],
+            accessModifier: sourcesInJoin.accessModifier,
         };
+        fieldsByName.set(joinName, compositeJoin);
     }
+    return {
+        type: 'composite',
+        // TODO Use sourceRefs rather than sourceDefs when possible to avoid potential
+        // explosion of source defs...
+        sources: sources.map(s => s.sourceDef),
+        connection,
+        fields: [...fieldsByName.values()],
+        dialect,
+        name,
+        // TODO actually compose the parameters?
+        parameters: sources[0].sourceDef.parameters,
+    };
+}
+function prettyType(a) {
+    return `\`${a.type}\``;
 }
-exports.CompositeSource = CompositeSource;
 //# sourceMappingURL=composite-source.js.map

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

@@ -157,6 +157,7 @@ type MessageParameterTypes = {
     'field-list-edit-not-found': string;
     'unexpected-element-type': string;
     'field-not-found': string;
+    'composite-field-type-mismatch': string;
     'invalid-composite-source-input': string;
     'invalid-composite-field-usage': {
         newUsage: FieldUsage[];

package/dist/model/composite_source_utils.d.ts

@@ -35,6 +35,11 @@ type CompositeError = {
     };
 };
 type CompositeIssue = {
+    type: 'join-failed';
+    failures: CompositeFailure[];
+    path: string[];
+    firstUsage: FieldUsage;
+} | {
     type: 'missing-field';
     field: FieldUsage;
 } | {

package/dist/model/composite_source_utils.js

@@ -100,9 +100,21 @@ sources) {
                 filterList: [...((_b = source.filterList) !== null && _b !== void 0 ? _b : []), ...((_c = base.filterList) !== null && _c !== void 0 ? _c : [])],
             };
             const joinError = processJoins(path, base, rootFields, nests, expandedCategorized);
-            // Fourth point where we abort: if a join failed we just completely give up
-            if (joinError.error !== undefined) {
-                return { error: joinError.error };
+            // Fourth point where we abort: if a join failed
+            if (joinError.errors.length > 0) {
+                for (const error of joinError.errors) {
+                    if (error.error.code !== 'no_suitable_composite_source_input') {
+                        return { error: error.error };
+                    }
+                    fail({
+                        type: 'join-failed',
+                        failures: error.error.data.failures,
+                        path: error.error.data.path,
+                        firstUsage: error.firstUsage,
+                    });
+                }
+                abort();
+                continue overSources;
             }
             joinsProcessed = true;
             if (nests !== undefined) {
@@ -146,8 +158,8 @@ sources) {
             };
         }
         const joinResult = processJoins(path, base, rootFields, nests, categorizeFieldUsage(expanded.result));
-        if (joinResult.error !== undefined) {
-            return { error: joinResult.error };
+        if (joinResult.errors.length > 0) {
+            return { error: joinResult.errors[0].error };
         }
         anyComposites || (anyComposites = joinResult.anyComposites);
     }
@@ -290,6 +302,7 @@ function processJoins(path, base, rootFields, nests, categorizedFieldUsage) {
     var _a, _b;
     let anyComposites = false;
     const fieldsByName = {};
+    const errors = [];
     for (const field of base.fields) {
         fieldsByName[(_a = field.as) !== null && _a !== void 0 ? _a : field.name] = field;
     }
@@ -297,20 +310,24 @@ function processJoins(path, base, rootFields, nests, categorizedFieldUsage) {
         const newPath = [...path, joinName];
         const join = fieldsByName[joinName];
         if (join === undefined) {
-            return {
+            errors.push({
                 error: {
                     code: 'composite_source_not_defined',
                     data: { path: newPath },
                 },
-            };
+                firstUsage: joinedUsage[0],
+            });
+            continue;
         }
         if (!(0, malloy_types_1.isJoined)(join)) {
-            return {
+            errors.push({
                 error: {
                     code: 'composite_source_not_a_join',
                     data: { path: newPath },
                 },
-            };
+                firstUsage: joinedUsage[0],
+            });
+            continue;
         }
         else if (!(0, malloy_types_1.isSourceDef)(join)) {
             // Non-source join, like an array, skip it (no need to resolve)
@@ -318,19 +335,25 @@ function processJoins(path, base, rootFields, nests, categorizedFieldUsage) {
         }
         const resolved = _resolveCompositeSources(newPath, join, genRootFields(rootFields, path, base.fields), nests, joinedUsage);
         if ('error' in resolved) {
-            return resolved;
+            errors.push({
+                error: resolved.error,
+                firstUsage: joinedUsage[0],
+            });
+            continue;
         }
         if (!resolved.anyComposites) {
             continue;
         }
         anyComposites = true;
         if (!(0, malloy_types_1.isJoinable)(resolved.success)) {
-            return {
+            errors.push({
                 error: {
                     code: 'composite_source_is_not_joinable',
                     data: { path: newPath },
                 },
-            };
+                firstUsage: joinedUsage[0],
+            });
+            continue;
         }
         fieldsByName[joinName] = {
             ...resolved.success,
@@ -340,7 +363,7 @@ function processJoins(path, base, rootFields, nests, categorizedFieldUsage) {
         };
         base.fields = Object.values(fieldsByName);
     }
-    return { anyComposites };
+    return { anyComposites, errors };
 }
 function resolveCompositeSources(source, segment, fieldUsage) {
     var _a;
@@ -449,7 +472,8 @@ function fieldUsageJoinPaths(fieldUsage) {
 exports.fieldUsageJoinPaths = fieldUsageJoinPaths;
 function isCompositeField(fieldDef) {
     var _a;
-    return 'e' in fieldDef && ((_a = fieldDef.e) === null || _a === void 0 ? void 0 : _a.node) === 'compositeField';
+    return (('e' in fieldDef && ((_a = fieldDef.e) === null || _a === void 0 ? void 0 : _a.node) === 'compositeField') ||
+        ((0, malloy_types_1.isJoined)(fieldDef) && fieldDef.type === 'composite'));
 }
 function getNonCompositeFields(source) {
     return source.fields.filter(f => !isCompositeField(f));
@@ -773,10 +797,14 @@ function logCompositeError(error, logTo) {
                         const fieldRef = `\`${issue.field.path.join('.')}\``;
                         logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: missing field ${fieldRef} in ${source}${requiredFields}`, { at: issue.field.at });
                     }
-                    else {
+                    else if (issue.type === 'missing-required-group-by') {
                         const fieldRef = `\`${issue.requiredGroupBy.path.join('.')}\``;
                         logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: missing group by ${fieldRef} as required in ${source}${requiredFields}`, { at: issue.requiredGroupBy.at });
                     }
+                    else {
+                        const joinRef = `\`${issue.path.join('.')}\``;
+                        logTo.logError('could-not-resolve-composite-source', `Could not resolve composite source: join ${joinRef} could not be resolved in ${source}${requiredFields}`, { at: issue.firstUsage.at });
+                    }
                 }
             }
         }

package/dist/version.d.ts

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

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.275';
+exports.MALLOY_VERSION = '0.0.276';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.275",
+  "version": "0.0.276",
   "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.275",
-    "@malloydata/malloy-interfaces": "0.0.275",
-    "@malloydata/malloy-tag": "0.0.275",
+    "@malloydata/malloy-filter": "0.0.276",
+    "@malloydata/malloy-interfaces": "0.0.276",
+    "@malloydata/malloy-tag": "0.0.276",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",
     "jaro-winkler": "^0.2.8",