feat(query): report the elementId Convert writes (#733)

[someshSandbox]

Fixes #733.

elementId is now a queryable property. It reports the elementId Convert writes for the element, from the writer's own identity tables.

// lib.sysml
package Lib { part def Engine { attribute mass : ScalarValues::Real; } }
// app.sysml
package App { private import Lib::*; part e : Engine; }

After ParseSources of both, select: ["@id", "elementId"]:

element	@id (unchanged)	elementId	Convert api-json @id
Lib::Engine	Lib::Engine	Lib__Engine	Lib__Engine
Lib::Engine::mass	Lib::Engine::mass	Lib__Engine__mass	Lib__Engine__mass
App::e	App::e	App__e	App__e
ScalarValues::Real (scope: ["ScalarValues::Real"])	ScalarValues::Real	14c0aa22-5489-59b5-b438-ded26e83ba31	the id every reference to it carries

On develop, select: ["elementId"] is INVALID_ARGUMENT (unknown query property "elementId").

Change:

• query.PropertyElementID (elementId) joins the closed property set, and OSLC maps sysml:elementId to it.

  • PropertyReader.WithElementID supplies it; without one it is absent.
  • An empty select doesn't report it (query.DefaultProjection), since reading it converts the model. A query that names it in select or where gets it.

• export.ElementIDs reads the ids from a conversion of the model, made the way Convert makes it for that model_hash:

  • one document is converted from its text (NewElementIDsOfDocument, as sysmlToRDFWith does);
  • several are converted from what parse read (NewElementIDs, modelToRDF, which ModelToRDFWith now wraps).

  So a library file's copy, a declared ElementId and scope qualification come out as written. A standard-library element the model doesn't declare reports the normative id every reference to it carries.

• A model Convert refuses has no elementIds. A query reading elementId of it is FAILED_PRECONDITION with the conversion's reason, and a query not reading it is unaffected.

• A library element the model gives an id of its own (metadata … ElementId about ScalarValues::Boolean { id = "custom-boolean"; }) reports no elementId. Convert writes no id for it: a reference to it is {"@ref": "ScalarValues::Boolean"}.

• The service builds the ids once per cached model (CachedModel.elementIDs), in a structured query and in OSLC alike.

• api.md documents the property. In a model of several identity scopes, the API JSON @id carries the scope qualifier (.one:P__A) while elementId is the element's own (P__A), as Convert writes it.

Tests:

• internal/frontend/grpc/query_element_id_test.go: every element a whole-model query returns has elementId equal to Convert's elementId for the same qualified name, and equal to its @id where no scope qualifies it. The models:
  • two documents with a cross-document reference;
  • an unnamed member and a quoted name;
  • a declared ElementId;
  • two identity scopes.
• The same file also checks:
  • ScalarValues::Real's normative id, both referenced from a model and in a parsed copy of ScalarValues.kerml;
  • a model Convert refuses (two documents declaring package P): FAILED_PRECONDITION when elementId is selected, success otherwise, and no elementId for an empty select;
  • no elementId for an annotated library element, alongside Convert's @ref for it.
• internal/semantic/query/..., internal/translate/..., internal/frontend/grpc/..., tests/grpc/... and tests/export/... pass.

🤖 Generated with Claude Code

[devin-ai-integration]

Note

Newer findings are available below. Devin Review posted a newer report on this PR, in addition to the findings presented here.

Devin Review found 3 potential issues.

2 flags not posted on this PR by your GitHub settings — view them in Devin Review. (Configure)

[devin-ai-integration]

🔴 Distinct scoped elements share one reported ID

When separate identity scopes declare the same qualified name, byName overwrites one element's ID with the other's. Queries for both elements then report the same ID, even when conversion writes different IDs.

Learn more

A model's RDF conversion permits repeated qualified names in different identity scopes by qualifying their subject IRIs; modelToRDF activates this when multiple scopes exist. A map keyed only by qualified name cannot distinguish those subjects, and Of receives only the name rather than the queried symbol. If the scopes declare distinct IDs for the same name, one result necessarily receives the wrong ID.

Example: Two documents each declare package P in different ProjectRef scopes, with declared IDs first-p and second-p. Conversion writes two distinct scoped package subjects, but querying both P symbols returns second-p for both.

Recommended fix: Key the lookup by an identity that distinguishes the declaration, such as the document and node/symbol, and associate each converted subject with its declaration. Pass the queried symbol into Of instead of relying on a qualified name alone.

---

Was this helpful? React with 👍 or 👎 to provide feedback.