=Paper=
{{Paper
|id=Vol-2721/paper590
|storemode=property
|title=on2ts- Typescript generation from OWL ontologies and SHACL
|pdfUrl=https://ceur-ws.org/Vol-2721/paper590.pdf
|volume=Vol-2721
|authors=Jesse Wright,Sergio José Rodríguez Méndez,Armin Haller,Kerry Taylor,Pouya Ghiasnezhad Omran
|dblpUrl=https://dblp.org/rec/conf/semweb/WrightMHTO20a
}}
==on2ts- Typescript generation from OWL ontologies and SHACL==
https://ceur-ws.org/Vol-2721/paper590.pdf
on2ts - Typescript Generation from OWL
Ontologies and SHACL
Jesse Wright1,2[0000−0002−5771−988X] , Sergio J. Rodrı́guez
1,3[0000−0001−7203−8399]
Méndez , Armin Haller1,2[0000−0003−3425−0780] , Kerry
1,2[0000−0003−2447−1088]
Taylor , and Pouya G. Omran1,4[0000−0002−4473−3877]
1
Australian National University, Canberra ACT 2601, AU
2
{firstname.lastname}@anu.edu.au
3
Sergio.RodriguezMendez@anu.edu.au
4
P.G.Omran@anu.edu.au
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 develop-
ing front-end applications that interact with these KGs. These opportu-
nities are often unrealised as Web developers are required to interpret
OWL and SHACL statements in order to write front-end code that con-
forms with the back-end data model. This paper introduces on2ts, a
developer tool that automatically converts OWL definitions and SHACL
constraints into Typescript [1] classes and interfaces. This enables de-
velopers to import these definitions 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 ap-
plications and providing an appropriate level of abstraction for front-end
development environments.
Keywords: Typescript · Javascript · SHACL · OWL · Ontology · Code
Generation · linked-data · Developer Tool
1 Introduction
Despite rapid growth in the development of back-end technologies for the Se-
mantic 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 histor-
ically, 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 different internal methods for handling data structures.
Copyright c 2020 for this paper by its authors. Use permitted under Creative Com-
mons License Attribution 4.0 International (CC BY 4.0).
Wright et al.
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 difficulty of working with types under the open-
world 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 first issue has recently come to light in Semantic web communities fo-
cused on front-end development. The authors of LDflex 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 sufficient for small scale applications, our experience with the devel-
opment of larger applications such as Schı́matos 5 [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 specifi-
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 Protégé’s code generator [11], the OWL-API [2] for
Java and owl2perl [3] for Perl. Additionally there are some Javascript/Type-
script 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 de-
veloped 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 recom-
mendation. 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 definitions 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 de-
velop 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 definitions 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 StackOverflow indicates that ∼ 67% of web
developers are using Typescript in their projects [6].
8
https://code.visualstudio.com/docs/languages/typescript
on2ts
of associated SHACL shapes. Javascript applications may also import libraries
written in Typescript and benefit from tooltips derived from Typescript defini-
tions.
2 From ontologies and SHACL to Typescript
on2ts uses LDflex [12] to read OWL axioms and SHACL constraints. ts-morph [9]
is then used to generate the subsequent Typescript files. In this process, the
ontology file is used to generate the base structure of classes, which includes
encoding domain, range, subclass and type declarations. In contrast the SHACL
files 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 simplified 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 definitions are encoded within
the Typescript files, all information is self contained in the program and hence
Wright et al.
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 supple-
ment the ontology/SHACL definitions. For instance, we need to add custom
validator methods to each class of SHACL validators. These methods are inte-
grated into the objects using ts-morph during the code generation process.
This tool does not yet process the complete OWL2 specification. The current
focus of development is on ease of usage rather than complete coverage of the
specification.
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 con-
straints allow developers or information architects to define a set of conditions
that data must satisfy in order for applications to reasonably perform. By encod-
ing 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:property [
sh:path ex:position ; sh:path ex:inPlay ;
sh:datatype xsd:string ; sh:value true ;
sh:pattern "^[A-H][1-8]\$" ; ] .
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 specification is obtained.
on2ts
3 Availability
This tool is under active development, at https://github.com/jeswr/on2ts
along with sample Typescript files generated from several ontologies. In the
repository we are also building the plugin required to use LDflex [12] in con-
junction with these files. 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 definitions. 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 Rec-
ommendation, w3c (July 2017), https://www.w3.org/TR/shacl
5. ontola: ontola/ontologies: v2.0.1 (Aug 2020), https://github.com/ontola/
ontologies
6. Overflow”, S.: Stack overflow developer survey 2020 (2020), https://insights.
stackoverflow.com/survey/2020
7. Prud’hommeaux, E., Boneva, I., Gayo, J.E.L., Kellogg, G.: Shape expressions lan-
guage 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., Lemée, J.B., Willems,
J., Shurmer, J., de Jong, M.: Ldflex/ldflex: v2.11.1 (Jun 2020).
https://doi.org/10.5281/zenodo.3894538, https://doi.org/10.5281/zenodo.
3894538
13. Wright, J., Rodrı́guez Méndez, S., Haller, A., Taylor, K., Omran, P.: Schimatos:
a SHACL-based web-form generator for knowledge graph editing. In: Proc. In-
ternational Semantic Web Conference, ISWC2020. p. 16 pages. Springer LNCS
(November 2020), To appear.