simple-graph-query 2.7.0 → 2.7.2

package/dist/simple-graph-query.bundle.js

@@ -48626,10 +48626,19 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             // Convert numeric and boolean strings to their actual types
             relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
             relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.convertToBoolean(value) : value));
-            this.relationCache.set(relation.name, relationAtoms);
-            // Build index for this relation: first element -> all tuples starting with that element
+            // Relation NAMES are not unique — only the qualified id (`Sig<:label`) is.
+            // e.g. `open util/ordering[A]` and `open util/ordering[B]` both expose a field
+            // named `Next` (`A/Ord<:Next` and `B/Ord<:Next`). A bare-name reference must
+            // resolve to the UNION of every relation sharing that name; keying by name and
+            // overwriting silently erases all but the last. https://github.com/sidprasad/simple-graph-query/issues/55
+            const existing = this.relationCache.get(relation.name);
+            this.relationCache.set(relation.name, existing ? existing.concat(relationAtoms) : relationAtoms);
+        }
+        // Build first-element indexes from the merged (union'd) tuples, so an index
+        // never reflects only a subset of a name's relations.
+        for (const [name, tuples] of this.relationCache.entries()) {
             const relationIndex = new Map();
-            for (const tuple of relationAtoms) {
+            for (const tuple of tuples) {
                 if (tuple.length > 0) {
                     const key = tuple[0];
                     if (!relationIndex.has(key)) {
@@ -48638,7 +48647,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     relationIndex.get(key).push(tuple);
                 }
             }
-            this.relationIndexCache.set(relation.name, relationIndex);
+            this.relationIndexCache.set(name, relationIndex);
         }
     }
     //helper function
@@ -50821,10 +50830,17 @@ const UNKNOWN = { kind: "unknown" };
 class SchemaInfo {
     constructor(schema) {
         this.typesById = new Map(schema.getTypes().map((t) => [t.id, t]));
-        this.relationsByName = new Map(schema.getRelations().map((r) => [r.name, r]));
+        this.relationsByName = new Map();
+        for (const r of schema.getRelations()) {
+            const existing = this.relationsByName.get(r.name);
+            if (existing)
+                existing.push(r);
+            else
+                this.relationsByName.set(r.name, [r]);
+        }
     }
     getType(id) { return this.typesById.get(id); }
-    getRelation(name) { return this.relationsByName.get(name); }
+    getRelations(name) { return this.relationsByName.get(name) ?? []; }
     // A ⊆ B when B is in A's lineage. `IType.types` is the lineage in ascending
     // order, conventionally starting with the type itself.
     isSubtypeOf(a, b) {
@@ -50965,7 +50981,7 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
         if (!this.schema)
             return undefined;
         for (const name of names) {
-            if (this.schema.getType(name) || this.schema.getRelation(name)) {
+            if (this.schema.getType(name) || this.schema.getRelations(name).length > 0) {
                 return {
                     kind: "ill-typed",
                     reason: `cannot bind variable named '${name}': it is a reserved schema ` +
@@ -51746,11 +51762,26 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
             const t = this.schema.getType(id);
             if (t)
                 return { kind: "typed", arity: 1, columnTypes: [t.id] };
-            const r = this.schema.getRelation(id);
-            if (r) {
-                const cols = r.types;
+            const rels = this.schema.getRelations(id);
+            if (rels.length === 1) {
+                const cols = rels[0].types;
                 return { kind: "typed", arity: cols.length, columnTypes: cols };
             }
+            if (rels.length > 1) {
+                // A bare name denotes the union of every relation sharing it. Different
+                // arities have no single typing, so stay UNKNOWN. When arities agree,
+                // keep the arity; keep per-column types only where every relation agrees
+                // (otherwise omit, so downstream disjointness checks soundly skip rather
+                // than fire on a widened column).
+                const arity = rels[0].types.length;
+                if (rels.every((r) => r.types.length === arity)) {
+                    const cols = rels[0].types.map((col, i) => rels.every((r) => r.types[i] === col) ? col : undefined);
+                    const allKnown = cols.every((c) => c !== undefined);
+                    return allKnown
+                        ? { kind: "typed", arity, columnTypes: cols }
+                        : { kind: "typed", arity };
+                }
+            }
         }
         return UNKNOWN;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simple-graph-query",
-  "version": "2.7.0",
+  "version": "2.7.2",
   "description": "TypeScript evaluator for Forge expressions with browser-compatible UMD bundle",
   "main": "dist/simple-graph-query.bundle.js",
   "types": "dist/index.d.ts",
@@ -33,10 +33,15 @@
     "prepublishOnly": "npm run build:full",
     "serve": "python3 -m http.server 8080",
     "test": "jest",
-    "antlr4ts": "cd src/forge-antlr && antlr4ts -visitor ForgeLexer.g4 Forge.g4 && cd ../.."
+    "antlr4ts": "cd src/forge-antlr && antlr4ts -visitor ForgeLexer.g4 Forge.g4 && cd ../..",
+    "release:tag": "git diff-index --quiet HEAD -- || (echo 'Working tree is dirty, commit first' && exit 1) && git tag v$npm_package_version && git push origin v$npm_package_version"
   },
   "author": "Siddhartha Prasad",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sidprasad/simple-graph-query.git"
+  },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "antlr4ts-cli": "^0.5.0-alpha.4",