The goal of this issue is to develop conformance test suite for the Query endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/queries/

5. DELETE /projects/

/queries/

/results
7. GET /projects/

/queries/query-results
Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Tag endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/tags/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Diff and Merge endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /projects/

/branches/

/merge
Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Meta endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /meta/datatypes
2. GET /meta/datatypes/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The spec says: "DataVersion.identity should be populated with the DataIdentity that will be deleted in the new commit. When a DataIdentity is deleted in a commit, all its versions (DataVersion) are also deleted,"

This sounds wrong - presumably DataVersions referenced by earlier Commits need to be maintained. This does seem to be the way that the reference implementation behaves.

The goal of this issue is to develop conformance test suite for the Element and Relationship endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/commits/

/roots
4. GET /projects/

/commits/

/elements/

/relationships

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The goal of this issue is to develop conformance test suite for the Branch endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/branches/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

Description - The goal of this issue is to develop conformance test suite for the Commit endpoints in the REST/HTTP PSM. This includes the following endpoints:

1. GET /projects/

/commits/

/changes
5. GET /projects/

/commits/

/changes/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

Description - The goal of this issue is to develop conformance test suite for Project endpoints in the REST/HTTP PSM. This includes the following endpoints:
1. GET /projects
2. POST /projects
3. GET /projects/

5. DELETE /projects/

Other details:
1. Tests should be defined for each endpoint individually.
2. Both positive and negative scenarios should be tested for each endpoint.
3. Each test must include setup, test, and tear down steps.
4. Tests will be written in Java using the JUnit framework (widely adopted).

The API PIM specification has a Record entity with humanIdentifier attribute. Commit entity inherits from Record, therefore it is expected for humanIdentifier attribute to exist in Commit entity as well. This is not the case at the moment when looking at the API JSON schema.

humanIdentifier is crucial for tool vendors to be able to relate commit UUIDs to version identifiers that are specific to the different versioning schemas used by different tool vendors.

Since OSLC vocabulary gets generated automatically from SysML2 metamodel, it would make sense for it to include typing hierarchy (eSuperTypes of eClassifiers --> rdfs:subClassOf statements) which would make the vocabulary more semantically “rich” and enable some RDFS reasoning on top of it.

OSLC API Resource Shapes and Vocabulary (both for KerML and SysML2) get automatically generated from respective Ecore metamodels, which leads to OCL expressions ending up as part of documentation in <rdfs:comment> properties. This makes the generated vocabularies and shapes super ugly and hard to read, e.g.:

<rdf:Description rdf:about="https://www.omg.org/spec/SysML/20230201/vocab#Expression">
    <rdfs:comment>&lt;p&gt;An Expression is a Step that is typed by a Function. An Expression that also has a Function as its &lt;code&gt;featuringType&lt;/code&gt; is a computational step within that Function. An Expression always has a single &lt;code&gt;result&lt;/code&gt; parameter, which redefines the &lt;code&gt;result&lt;/code&gt; parameter of its defining &lt;code&gt;function&lt;/code&gt;. This allows Expressions to be interconnected in tree structures, in which inputs to each Expression in the tree are determined as the results of other Expressions in the tree.&lt;/p&gt;

isModelLevelEvaluable = modelLevelEvaluable(Set(Element){})
specializesFromLibrary("Performances::evaluations")
owningMembership &lt;&gt; null and 
owningMembership.oclIsKindOf(FeatureValue) implies
    let featureWithValue : Feature = 
        owningMembership.oclAsType(FeatureValue).featureWithValue in
    featuringType = featureWithValue.featuringType
ownedMembership.selectByKind(ResultExpressionMembership)-&gt;
    forAll(mem | ownedFeature.selectByKind(BindingConnector)-&gt;
        exists(binding |
            binding.relatedFeature-&gt;includes(result) and
            binding.relatedFeature-&gt;includes(mem.ownedResultExpression.result)))</rdfs:comment>

Prior OSLC artifact generation we need to figure out how to distinguish between normative documentation of metamodel objects (eClassifiers and eOperations) vs their OCL expressions in the original Ecore files.

it is unclear if queryConformace implies derivedProperties conformance. In other words, does the query service provider need to support derived properties or not.

The POST projects/

/commits endpoint in the OpenAPI spec for REST/HTTP PSM includes examples for creating elements (ElementCommitRequest), relationships (RelationshipCommitRequest), project usages (ProjectUsageCommitRequest), and others. See the attached screenshot. There is also an example (DeleteCommitRequest) that shows the commit request body when elements are to be deleted.

It will help to add specific examples (as below) that provide details of Commit.change when elements are to be created, updated, or deleted.

• ElementCreateCommitRequest
• ElementUpdateCommitRequest
• ElementDeleteCommitRequest

In section 7.1.2 - the Data Versioning API Model, versionedData is a derived relationship. The spec does not specify what/how it is derived from.

The beta spec should provide details on deleting a project that has commits with data.

ProjectService in the PIM includes an operation "deleteProject" to delete a project. An equivalent endpoint is available in the REST/HTTP PSM (DELETE /projects/

).

However the specification should provide details, including recommended practices on what happens to the contents of a project and project usages when a project is deleted.

Note that authorization (permissions) are outside the scope of the specification but related to this action.

The goal of this task is to develop conformance test cases for the OSLC PSM of the Systems Modeling API and Services. Annex A of the specification includes Conformance Test Suite for the PIM of the API & Services. API & Services Providers and Consumers will generally conform to the individual PSMs, even though PIM-level conformance is allowed. See Section 2 (Conformance) for details. Hence, the specification should provide a Conformance Test Suite for the OSLC PSM.

In the PIM, ProjectDataVersioningService.diffCommits(...) operation returns a set of differences between two commits (baseCommit and compareCommit). This includes elements added, updated, or deleted in the compareCommit compared to the baseCommit.
The set of differences returned from the diffCommits operations can be large, even though served using pagination.
In many scenarios, consumers of the API may only be interested in specific types of changes, e.g. elements added, or updated, or deleted.
Can we add an additional argument to the diffCommits operation that returns a filtered set of differences based on a change type versus all the differences.

In the PIM, ProjectDataVersioningService.getCommitChange(...) operation returns a set of changes in a given commit compared to the previous commit(s). This includes elements added, updated, or deleted in the given commit. The set of changes returned from the getCommitChange(...) operations can be large, even though served using pagination. In many scenarios, consumers of the API may only be interested in specific types of changes, e.g. elements added, or updated, or deleted.
Can we add an additional argument to the getCommitChange(...) operation that returns a filtered set of changes based on a change type versus all the changes?

While reading through Release 2023-02 of the Systems Modeling Application Programming Interface (API) and Services.pdf i think the following is incorrect:

Project: missing property created:ISO8601DateTime
Branch: owningProject is the Project that owns the given Branch -> this property should not be described here as Branch is a subclass of CommitReference which already has a property called owningProject
Tag: owningProject is the Project that owns the given Tag-> this property should not be described here as Tag is a subclass of CommitReference which already has a property called owningProject

The query is only described using abstract syntax. While most of the API REST commands are fairly straightforward, it is not the case for query. There needs to be a BNF production that specifies the concrete syntax for query, which is the string that would be passed in the body of the post command

The goal of this task is to develop conformance test cases for the REST/HTTP PSM of the Systems Modeling API and Services.
Annex A of the specification includes Conformance Test Suite for the PIM of the API & Services.
API & Services Providers and Consumers will generally conform to the individual PSMs, even though PIM-level conformance is allowed. See Section 2 (Conformance) for details. Hence, the specification should provide a Conformance Test Suite for the REST/HTTP PSM.

In the Project Data Versioning PIM (Sec 7.1.2, Fig. 5), the relationship between DataVersion and its payload Data is inconsistent with the representation of deletion in Commits.

As per page 71, Commit::change "is the set of DataVersion records representing Data that is created, updated, or deleted in the
Commit". This implies that Data being deleted by the Commit must be expressed as a DataVersion object somehow.

The approach followed by the JSON/RPC PSM is that the DataVersion has an identity that identifies the Data, but the payload is null. However, in the PIM, the multiplicity of DataVersion::payload does not allow it to be null. So seemingly the PIM cannot actually express a Commit that deletes things.

In the API PIM, under ElementNavigationService, there's a getElements service which is dedicated for dumping the entire model content at a given commit.

This is an overkill for a use case when only part of the model content (e.g. a package) is required to do analysis (or any other task) on.

While theoretical a workaround could be used via getRelationshipsByRelatedElement by retrieving all of the owned elements under specified owner, this would result in gazillion separate calls and would not be efficient under slower networks.

Proposal - introduce a new service getOwnedElements with an ability to collect all of the owned elements recursively under specified root or enrich getElements with optional arguments allowing to achieve the same.