on2ts - Typescript Generation from OWL Ontologies and SHACL

Abstract

Ontologies expressed in OWL and their associated SHACL [4] constraints contain detailed metadata and assumptions on Knowledge Graphs (KGs). With this information comes the possibility of developing front-end applications that interact with these KGs. These opportunities are often unrealised as Web developers are required to interpret OWL and SHACL statements in order to write front-end code that conforms with the back-end data model. This paper introduces on2ts, a developer tool that automatically converts OWL de nitions and SHACL constraints into Typescript [1] classes and interfaces. This enables developers to import these de nitions directly into their application. The authors have developed this tool with the goal of reducing development time of linked-data applications, improving type-safety of linked-data applications and providing an appropriate level of abstraction for front-end development environments.

Keywords

• Typescript
• Javascript
• SHACL
• OWL
• Ontology
• Code
• Generation
• linked-data
• Developer Tool

-

Despite rapid growth in the development of back-end technologies for the Semantic Web, front-end tools remain limited. on2ts aims to address several issues hindering development of scalable linked-data applications and libraries: 1. Developers have been slow to adopt Semantic Web technologies, and historically, the developer experience in linked-data applications has been poor. 2. Applications and libraries which are designed for the same ontology are often incompatible due to di erent internal methods for handling data structures. 3. There are few linked-data libraries which make use of Typescript (or similar typed languages that are used by developers of large scale web applications). This is unsurprising given the di culty of working with types under the openworld assumption made by Semantic Web languages. The use of types in linked data applications is now becoming easier with the advent of constraint languages such as ShEx [ 7 ] and SHACL [ 4 ]. 4. Open world assumptions in linked-data environments force developers to handle cases that are not encountered in traditional databases.

The rst issue has recently come to light in Semantic web communities focused on front-end development. The authors of LD ex note that: \use cases indicate that designing a linked-data developer experience|analogous to a user experience|is crucial for adoption" [ 12 ] and have begun to address this issue with APIs which abstract away complexities of RDF and SPARQL. Whilst such tooling is su cient for small scale applications, our experience with the development of larger applications such as Sch matos5 [ 10, 13 ] indicates that these libraries require the support of ontology-based objects if they are to be used in scalable applications. In addition, we are not aware of any tooling that speci cally aids Typescript/Javascript developers in handling the complexities of open world assumptions arising from the RDF data model. In this paper, we discuss how on2ts can be used to resolve these issues.

The authors are aware of similar code generators which have been developed for other languages such as Protege's code generator [ 11 ], the OWL-API [ 2 ] for Java and owl2perl [ 3 ] for Perl. Additionally there are some Javascript/Typescript libraries [ 5 ] that extract some low level information such as the IRIs and TermTypes from ontologies. Crucially, we note that none of these frameworks make use of SHACL to provide additional or customised validation behavior.

The Shapes Constraint Language (SHACL) [ 4 ] is a W3C recommendation developed to express conditions, as shape graphs, for validating RDF-based KGs. Thus domain-relevant structure can be enforced. Whilst similar languages such as ShEx [ 7 ] exist, the authors have chosen to use SHACL as it is a W3C recommendation. We additionally note that tools including RDFShape [ 8 ] enable the conversion from ShEx to SHACL.

Typescript is an open-source language developed by Microsoft which forms a superset of Javascript. It introduces static type de nitions that \describe the shape of an object, providing better documentation, and allowing Typescript to validate that your code is working correctly"6. Reasons for choosing to develop on2ts in Typescript include; the language's increasing popularity7 and the enhanced developer experience that Typescript provides when working in most IDEs8. Furthermore, static typing can help developers use patterns that accurately match de nitions of OWL ontologies and adhere to the constraints 5 on2ts was initially created to support Sch matos 6 https://www.typescriptlang.org/ 7 A recent survey of 65,000 developers by StackOver ow indicates that developers are using Typescript in their projects [ 6 ]. 8 https://code.visualstudio.com/docs/languages/typescript 67% of web of associated SHACL shapes. Javascript applications may also import libraries written in Typescript and bene t from tooltips derived from Typescript de nitions. 2

From ontologies and SHACL to Typescript on2ts uses LD ex [ 12 ] to read OWL axioms and SHACL constraints. ts-morph [ 9 ] is then used to generate the subsequent Typescript les. In this process, the ontology le is used to generate the base structure of classes, which includes encoding domain, range, subclass and type declarations. In contrast the SHACL les are used to generate validators that are applied when instantiating or loading an instance of a given class. 2.1 Exotic Objects and Proxies [Data from ontologies] on2ts makes use of exotic objects and proxies to allow Javascript/Typescript developers to interact with ontologies using familiar patterns of Object Oriented Programming. For instance the Symbol.hasInstance method is overwritten on the classes generated by on2ts. This enables the instanceof keyword to have the same behavior as a/rdf:type in a SPARQL query (including inferencing using subclass/subproperty relations). This means that if we have const John = new foaf.Person(`ex:John') then John instanceof foaf.Person, John instanceof foaf.Agent and foaf.Agent instanceof owl.Class all return true. A simpli ed implementation of this is given as follows: static [Symbol.hasInstance](obj: any): boolean { return obj.constructor === this // John instanceof foaf.Person // foaf.Agent instanceof owl.Class || obj.rdfType === this // John instanceof Base || obj.constructor.__proto__ === this // John instanceof foaf.Agent || obj.constructor.getExtends?.()

.some((extend: typeof Base) => extend instanceof this) } similarly we have overwritten the in operator to check if an instance has a given property within the data model. For instance as below function handlePerson(person: Person): void { if (ex.SupervisorOf in person) {...} else {...}} on2ts similarly encodes information related to domain/range and datatype properties. Importantly, note that as the ontology de nitions are encoded within the Typescript les, all information is self contained in the program and hence these operations require no external API calls beyond the initial loading of ex:John.

In some cases we need to add Javascript/Typescript methods to supplement the ontology/SHACL de nitions. For instance, we need to add custom validator methods to each class of SHACL validators. These methods are integrated into the objects using ts-morph during the code generation process.

This tool does not yet process the complete OWL2 speci cation. The current focus of development is on ease of usage rather than complete coverage of the speci cation. 2.2

Data from SHACL Traditional applications that interact with SQL databases are programmed against a strict set of assumptions that are encoded into the model of the database.

The open world assumption of RDF data models forces developers to work many cases that would traditionally not have to be considered. SHACL constraints allow developers or information architects to de ne a set of conditions that data must satisfy in order for applications to reasonably perform. By encoding this information into an applications data model, validation of data entering the application can be automated and programmers can work under assumptions that they are traditionally used to.

Consider a linked-data application for playing a game of chess. A reasonable assumption is that each piece in play lies in a valid position on the 8 8 board. This constraint is given as follows: ex:inPlayShape a sh:nodeShape ; sh:property [ sh:path ex:position ; sh:datatype xsd:string ; sh:pattern "^[A-H][ 1-8 ]\$" ; ] .

] ; sh:property [ sh:path ex:inPlay ; sh:value true ;

If this SHACL constraint is applied (at code generation time) to the class ex:inPositionPiece it becomes safe to assume that if the code const piece = new inPositionPiece(loadedPiece) runs without error, then the piece will be in a valid position on the playing board. Developers could customise the error handling for invalid data using a try/catch statement. In other applications, they may choose to call a SHACL form generation tool such as Sch matos [ 10, 13 ] so that users can correct missing or invalid data before the application continues. An example use case for this is generating a form for users to enter their banking details before an application loads the payment details for making a purchase.

The base class structure of the SHACL validator is generated using on2ts. We have then provided a function for each validation constraint. Consequently full coverage of the SHACL speci cation is obtained. This tool is under active development, at https://github.com/jeswr/on2ts along with sample Typescript les generated from several ontologies. In the repository we are also building the plugin required to use LD ex [ 12 ] in conjunction with these les. Demonstration videos and further use cases will be added during development. Some on2ts features discussed in this paper remain in development at the time of writing.

References

1. Bierman , G. , Abadi , M. , Torgersen , M. : Understanding typescript . In: Jones, R . (ed.) ECOOP 2014 { Object-Oriented Programming . pp. 257 { 281 . Springer Berlin Heidelberg, Berlin, Heidelberg ( 2014 )

2. Horridge , M. , Bechhofer , S.: The owl api: A java api for owl ontologies . Semantic Web 2 ( 1 ), 11 { 21 ( 2011 ). https://doi.org/10.3233/SW-2011-0025

3. Kawas , E. , Wilkinson , M.D.: OWL2Perl: creating Perl modules from OWL class de nitions . Bioinformatics 26 ( 18 ), 2357 { 2358 (07 2010 ). https://doi.org/10.1093/bioinformatics/btq416, https://doi.org/10.1093/ bioinformatics/btq416

4. Knublauch , H. , Kontokostas , D. : Shapes constraint language (SHACL) . W3C Recommendation, w3c (July 2017 ), https://www.w3.org/TR/shacl

5. ontola: ontola/ontologies: v2.0.1 (Aug 2020 ), https://github.com/ontola/ ontologies

6. Over ow" , S.: Stack over ow developer survey 2020 ( 2020 ), https://insights. stackoverflow.com/survey/2020

7. Prud'hommeaux , E., Boneva , I. , Gayo , J.E.L. , Kellogg , G.: Shape expressions language 2.1 . Final community group report 8 october 2019 , W3C Community Group ( 2019 ), http://shex.io/shex-semantics/

8. RDFShape: Parse and convert schema, http://rdfshape.herokuapp.com/ schemaConversions

9. Sherret , D.: dsherret/ts-morph : v7.3.0 (Aug 2020 ), https://github.com/ dsherret/ts-morph

10. University, A.N.: schimatos/schimatos. org: v0.0 .2-alpha ( Aug 2020 ). https://doi.org/10.5281/zenodo.3988748, https://doi.org/10.5281/zenodo. 3988748

11. University, S.: protegeproject/code-generator : v2.0.0 (Aug 2020 ), https:// github.com/protegeproject/code-generator

12. Verborgh , R. , Taelman , R. , Herwegen , J.V. , Lemee , J.B. , Willems , J. , Shurmer , J., de Jong, M.: Ld ex/ld ex: v2.11.1 (Jun 2020 ). https://doi.org/10.5281/zenodo.3894538, https://doi.org/10.5281/zenodo. 3894538

13. Wright , J. , Rodr guez Mendez, S. , Haller , A. , Taylor , K., Omran , P. : Schimatos: a SHACL-based web-form generator for knowledge graph editing . In: Proc. International Semantic Web Conference, ISWC2020 . p. 16 pages. Springer LNCS (November 2020 ), To appear.