Added schema-converter-shex

2 years ago · 02de7a1757
parent 3961705934
commit 02de7a1757
33 changed files with 5406 additions and 78 deletions
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -8,7 +8,8 @@
    "test": "lerna run test",
    "build": "lerna run build",
    "demo-react": "lerna run start --scope @ldo/demo-react",
-    "lint": "lerna run lint"
+    "lint": "lerna run lint",
+    "postinstall": "npm run build"
  },
  "devDependencies": {
    "@types/node": "^20.5.7",
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@ -19,7 +19,6 @@
    "test": "jest --coverage",
    "test:watch": "jest --watch",
    "prepublishOnly": "npm run test && npm run build",
-    "postinstall": "npm run build",
    "lint": "eslint src/** --fix --no-error-on-unmatched-pattern"
  },
  "repository": {
@ -45,11 +44,11 @@
  },
  "dependencies": {
    "@shexjs/parser": "^1.0.0-alpha.24",
+    "@ldo/schema-converter-shex": "^0.0.0",
    "child-process-promise": "^2.2.1",
    "commander": "^9.3.0",
    "ejs": "^3.1.8",
    "fs-extra": "^10.1.0",
-    "loading-cli": "^1.1.0",
-    "shexj2typeandcontext": "^2.0.0"
+    "loading-cli": "^1.1.0"
  }
 }
--- a/packages/cli/src/build.ts
+++ b/packages/cli/src/build.ts
@ -2,7 +2,7 @@ import fs from "fs-extra";
 import path from "path";
 import type { Schema } from "shexj";
 import parser from "@shexjs/parser";
-import shexjToTypeAndContext from "shexj2typeandcontext";
+import schemaConverterShex from "@ldo/schema-converter-shex";
 import { renderFile } from "ejs";
 import prettier from "prettier";
 import loading from "loading-cli";
@ -42,7 +42,7 @@ export async function build(options: BuildOptions) {
        .construct("https://ldo.js.org/")
        .parse(shexC);
      // Convert the content to types
-      const [typings, context] = await shexjToTypeAndContext(schema);
+      const [typings, context] = await schemaConverterShex(schema);
      await Promise.all(
        ["context", "schema", "shapeTypes", "typings"].map(
          async (templateName) => {
--- a/packages/ldo/README.md
+++ b/packages/ldo/README.md
@ -0,0 +1,367 @@
+# LDO (Linked Data Objects)
+
+LDO (Linked Data Objects) is a library that lets you easily manipulate RDF as if it were a standard TypeScript object that follows a [ShEx](https://shex.io) shape you define.
+
+For a full tutorial of using LDO to build React Solid applications, see [this tutorial](https://medium.com/@JacksonMorgan/building-solid-apps-with-ldo-6127a5a1979c).
+
+## Setup
+
+### Automatic Setup
+To setup LDO, `cd` into your typescript project and run `npx ldo-cli init`.
+
+```bash
+cd my-typescript-project
+npx ldo-cli init
+```
+
+### Manual Setup
+The following is handled by the __automatic setup__:
+
+Install the LDO dependencies.
+```bash
+npm install ldo
+npm install ldo-cli --save-dev
+```
+
+Create a folder to store your ShEx shapes:
+```bash
+mkdir shapes
+```
+
+Create a script to build ShEx shapes and convert them into Linked Data Objects. You can put this script in `package.json`
+```json
+{
+  ...
+  scripts: {
+    ...
+    "build:ldo": "ldo build --input ./shapes --output ./ldo"
+    ...
+  }
+  ...
+}
+```
+
+## Creating ShEx Schemas
+LDO uses [ShEx](https://shex.io) as a schema for the RDF data in your project. To add a ShEx schema to your project, simply create a file ending in `.shex` to the `shapes` folder.
+
+For more information on writing ShEx schemas see the [ShEx Primer](http://shex.io/shex-primer/index.html).
+
+
+`./shapes/foafProfile.shex`:
+```shex
+PREFIX ex: <https://example.com/>
+PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+
+ex:FoafProfile EXTRA a {
+  a [ foaf:Person ]
+    // rdfs:comment  "Defines the node as a Person (from foaf)" ;
+  foaf:name xsd:string ?
+    // rdfs:comment  "Define a person's name." ;
+  foaf:img xsd:string ?
+    // rdfs:comment  "Photo link but in string form" ;
+  foaf:knows @ex:FoafProfile *
+    // rdfs:comment  "A list of WebIds for all the people this user knows." ;
+}
+```
+
+To build the shape, run:
+```bash
+npm run build:ldo
+```
+
+This will generate five files:
+ - `./ldo/foafProfile.shapeTypes.ts` <-- This is the important file
+ - `./ldo/foafProfile.typings.ts`
+ - `./ldo/foafProfile.schema.ts`
+ - `./ldo/foafProfile.context.ts`
+
+## Simple Example
+
+Below is a simple example of LDO in a real use-case (changing the name on a Solid Pod)
+
+```typescript
+import { parseRdf, startTransaction, toSparqlUpdate, toTurtle } from "ldo";
+import { FoafProfileShapeType } from "./ldo/foafProfile.shapeTypes";
+
+async function run() {
+  const rawTurtle = `
+  <#me> a <http://xmlns.com/foaf/0.1/Person>;
+      <http://xmlns.com/foaf/0.1/name> "Jane Doe".
+  `;
+
+  /**
+   * Step 1: Convert Raw RDF into a Linked Data Object
+   */
+  const ldoDataset = await parseRdf(rawTurtle, {
+    baseIRI: "https://solidweb.me/jane_doe/profile/card",
+  });
+  // Create a linked data object by telling the dataset the type and subject of
+  // the object
+  const janeProfile = ldoDataset
+    // Tells the LDO dataset that we're looking for a FoafProfile
+    .usingType(FoafProfileShapeType)
+    // Says the subject of the FoafProfile
+    .fromSubject("https://solidweb.me/jane_doe/profile/card#me");
+
+  /**
+   * Step 2: Manipulate the Linked Data Object
+   */
+  // Logs "Jane Doe"
+  console.log(janeProfile.name);
+  // Logs "Person"
+  console.log(janeProfile.type);
+  // Logs 0
+  console.log(janeProfile.knows?.length);
+
+  // Begins a transaction that tracks your changes
+  startTransaction(janeProfile);
+  janeProfile.name = "Jane Smith";
+  janeProfile.knows?.push({
+    "@id": "https://solidweb.me/john_smith/profile/card#me",
+    type: {
+      "@id": "Person",
+    },
+    name: "John Smith",
+    knows: [janeProfile],
+  });
+
+  // Logs "Jane Smith"
+  console.log(janeProfile.name);
+  // Logs "John Smith"
+  console.log(janeProfile.knows?.[0].name);
+  // Logs "Jane Smith"
+  console.log(janeProfile.knows?.[0].knows?.[0].name);
+
+  /**
+   * Step 3: Convert it back to RDF
+   */
+  // Logs:
+  // <https://solidweb.me/jane_doe/profile/card#me> a <http://xmlns.com/foaf/0.1/Person>;
+  //   <http://xmlns.com/foaf/0.1/name> "Jane Smith";
+  //   <http://xmlns.com/foaf/0.1/knows> <https://solidweb.me/john_smith/profile/card#me>.
+  // <https://solidweb.me/john_smith/profile/card#me> a <http://xmlns.com/foaf/0.1/Person>;
+  //   <http://xmlns.com/foaf/0.1/name> "John Smith";
+  //   <http://xmlns.com/foaf/0.1/knows> <https://solidweb.me/jane_doe/profile/card#me>.
+  console.log(await toTurtle(janeProfile));
+  // Logs:
+  // DELETE DATA {
+  //   <https://solidweb.me/jane_doe/profile/card#me> <http://xmlns.com/foaf/0.1/name> "Jane Doe" .
+  // };
+  // INSERT DATA {
+  //   <https://solidweb.me/jane_doe/profile/card#me> <http://xmlns.com/foaf/0.1/name> "Jane Smith" .
+  //   <https://solidweb.me/jane_doe/profile/card#me> <http://xmlns.com/foaf/0.1/knows> <https://solidweb.me/john_smith/profile/card#me> .
+  //   <https://solidweb.me/john_smith/profile/card#me> <http://xmlns.com/foaf/0.1/name> "John Smith" .
+  //   <https://solidweb.me/john_smith/profile/card#me> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://xmlns.com/foaf/0.1/Person> .
+  //   <https://solidweb.me/john_smith/profile/card#me> <http://xmlns.com/foaf/0.1/knows> <https://solidweb.me/jane_doe/profile/card#me> .
+  // }
+  console.log(await toSparqlUpdate(janeProfile));
+}
+run();
+```
+
+## Getting an LDO Dataset
+
+An LDO Dataset is a kind of [RDF JS Dataset](https://rdf.js.org/dataset-spec/) that can create linked data objects.
+
+LDO datasets can be created in two ways:
+
+`createLdoDataset(initialDataset?: Dataset<Quad, Quad> | Quad[])`
+```typescript
+import { createLdoDataset } from "ldo";
+
+const ldoDataset = createLdoDataset();
+```
+
+ - `initialDataset`: An optional dataset or array of quads for the new dataset.
+
+`parseRdf(data: string, parserOptions?: ParserOptions)`
+```typescript
+import { parseRdf } from "ldo";
+
+const rawTurtle = "...";
+const ldoDataset = parseRdf(rawTurtle, { baseIRI: "https://example.com/" });
+```
+
+ - `data`: The raw data to parse as a `string`.
+ - `options` (optional): Parse options containing the following keys:
+    - `format` (optional): The format the data is in. The following are acceptable formats: `Turtle`, `TriG`, `N-Triples`, `N-Quads`, `N3`, `Notation3`.
+    - `baseIRI` (optional): If this data is hosted at a specific location, you can provide the baseIRI of that location.
+    - `blankNodePrefix` (optional): If blank nodes should have a prefix, that should be provided here.
+    - `factory` (optional): a RDF Data Factory from  [`@rdfjs/data-model`](https://www.npmjs.com/package/@rdfjs/data-model). 
+
+## Getting a Linked Data Object
+Once you have an LdoDataset we can get a Linked Data Object. A linked data object feels just like a JavaScript object literal, but when you make modifications to it, it will affect the underlying LdoDataset.
+
+Thie first step is defining which Shape Type you want to retrieve from the dataset. We can use the generated shape types and the `usingType()` method for this.
+
+```typescript
+import { FoafProfileShapeType } from "./ldo/foafProfile.shapeTypes.ts";
+
+// ... Get the LdoDataset
+
+ldoDataset.usingType(FoafProfileShapeType);
+```
+
+Next, we want to identify exactly what part of the dataset we want to extract. We can do this in a few ways:
+
+### `.fromSubject(entryNode)`
+`fromSubject` lets you define a an `entryNode`, the place of entry for the graph. The object returned by `jsonldDatasetProxy` will represent the given node. This parameter accepts both `namedNode`s and `blankNode`s. `fromSubject` takes a generic type representing the typescript type of the given subject.
+
+```typescript
+const profile = ldoDataset
+  .usingType(FoafProfileShapeType)
+  .fromSubject("http://example.com/Person1");
+```
+
+### `.matchSubject(predicate?, object?, graph?)`
+`matchSubject` returns a Jsonld Dataset Proxy representing all subjects in the dataset matching the given predicate, object, and graph.
+
+```typescript
+const profiles = ldoDataset
+  .usingType(FoafProfileShapeType)
+  .matchSubject(
+    namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"),
+    namedNode("http://xmlns.com/foaf/0.1/Person")
+  );
+profiles.forEach((person) => {
+  console.log(person.fn);
+});
+```
+
+### `.matchObject(subject?, predicate?, object?)`
+`matchObject` returns a Jsonld Dataset Proxy representing all objects in the dataset matching the given subject, predicate, and graph.
+
+```typescript
+const friendsOfPerson1 = ldoDataset
+  .usingType(FoafProfileShapeType)
+  .matchSubject(
+    namedNode("http://example.com/Person1"),
+    namedNode("http://xmlns.com/foaf/0.1/knows")
+  );
+friendsOfPerson1.forEach((person) => {
+  console.log(person.fn);
+});
+```
+
+### `.fromJson(inputData)`
+`fromJson` will take any regular Json, add the information to the dataset, and return a Jsonld Dataset Proxy representing the given data.
+
+```typescript
+const person2 = ldoDataset
+  .usingType(FoafProfileShapeType)
+  .fromJson({
+    "@id": "http://example.com/Person2",
+    fn: ["Jane Doe"],
+  });
+```
+
+## Getting and Setting Data on a Linked Data Object
+Once you've created a Linked Data Object, you can get and set data as if it were a normal TypeScript Object. For specific details, see the documentation at [JSONLD Dataset Proxy](https://github.com/o-development/jsonld-dataset-proxy/blob/master/Readme.md).
+
+```typescript
+import { LinkedDataObject } from "ldo";
+import { FoafProfileFactory } from "./ldo/foafProfile.ldoFactory.ts";
+import { FoafProfile } from "./ldo/foafProfile.typings";
+
+aysnc function start() {
+  const profile: FoafProfile = // Create LDO
+  // Logs "Aang"
+  console.log(profile.name);
+  // Logs "Person"
+  console.log(profile.type);
+  // Logs 1
+  console.log(profile.knows?.length);
+  // Logs "Katara"
+  console.log(profile.knows?.[0].name);
+  profile.name = "Bonzu Pippinpaddleopsicopolis III"
+  // Logs "Bonzu Pippinpaddleopsicopolis III"
+  console.log(profile.name);
+  profile.knows?.push({
+    type: "Person",
+    name: "Sokka"
+  });
+  // Logs 2
+  console.log(profile.knows?.length);
+  // Logs "Katara" and "Sokka"
+  profile.knows?.forEach((person) => console.log(person.name));
+}
+```
+
+## Converting a Linked Data Object back to RDF
+A linked data object can be converted into RDF in multiple ways:
+
+### `toTurtle(linkedDataObject)`
+```typescript
+import { toTurtle } from "ldo"
+// ...
+const rawTurtle: string = await toTurtle(profile);
+```
+
+### `toNTiples(linkedDataObject)`
+```typescript
+import { toNTriples } from "ldo"
+// ...
+const rawNTriples: string = await toNTriples(profile);
+```
+
+### `serialize(linkedDataObject, options)`
+```typescript
+const rawTurtle: string = await profile.$serialize({
+  format: "Turtle",
+  prefixes: {
+    ex: "https://example.com/",
+    foaf: "http://xmlns.com/foaf/0.1/",
+  }
+});
+```
+`serialize(linkedDataObject, options)` provides general serialization based on provided options:
+ - `foramt` (optional): The format to serialize to. The following are acceptable formats: `Turtle`, `TriG`, `N-Triples`, `N-Quads`, `N3`, `Notation3`.
+ - `prefixes`: The prefixes for those serializations that use prefixes.
+
+## Transactions
+
+Sometimes, you want to keep track of changes you make for the object. This is where transactions come in handy.
+
+To start a transaction, use the `startTransaction(linkedDataObject)` function. From then on, all transactions will be tracked, but not added to the original ldoDataset. You can view the changes using the `transactionChanges(linkedDataObject)` or `toSparqlUpdate(linkedDataObject)` methods. When you're done with the transaction, you can run the `commitTransaction(linkedDataObject)` method to add the changes to the original ldoDataset.
+
+```typescript
+import {
+  startTransaction,
+  transactionChanges,
+  toSparqlUpdate,
+  commitTransaction,
+} from "ldo"; 
+
+// ... Get the profile linked data object
+
+startTransaction(profile);
+profile.name = "Kuzon"
+const changes = transactionChanges(profile));
+// Logs: <https://example.com/aang> <http://xmlns.com/foaf/0.1/name> "Kuzon"
+console.log(changes.added?.toString())
+// Logs: <https://example.com/aang> <http://xmlns.com/foaf/0.1/name> "Aang"
+console.log(changes.removed?.toString())
+console.log(await toSparqlUpdate(profile));
+commitTransaction(profile);
+```
+
+## Other LDO Helper Functions
+
+### `getDataset(linkedDataObject)`
+Returns the Linked Data Object's underlying RDFJS dataset. Modifying this dataset will change the Linked Data Object as well.
+```typescript
+import { Dataset } from "@rdfjs/types";
+import { getDataset } from "ldo"
+const dataset: Dataset = dataset(profile);
+```
+
+## Sponsorship
+This project was made possible by a grant from NGI Zero Entrust via nlnet. Learn more on the [NLnet project page](https://nlnet.nl/project/SolidUsableApps/).
+
+[<img src="https://nlnet.nl/logo/banner.png" alt="nlnet foundation logo" width="300" />](https://nlnet.nl/)
+[<img src="https://nlnet.nl/image/logos/NGI0Entrust_tag.svg" alt="NGI Zero Entrust Logo" width="300" />](https://nlnet.nl/)
+
+## Liscense
+MIT
--- a/packages/ldo/src/LdoDataset.ts
+++ b/packages/ldo/src/LdoDataset.ts
@ -3,7 +3,7 @@ import jsonldDatasetProxy from "jsonld-dataset-proxy";
 import { WrapperSubscribableDataset } from "o-dataset-pack";
 import { LdoBuilder } from "./LdoBuilder";
 import type { ShapeType } from "./ShapeType";
-import type { LdoBase } from "./util";
+import type { LdoBase } from "./index";

 /**
 * Utility for building a linked data object
--- a/packages/ldo/test/LdoDataset.test.ts
+++ b/packages/ldo/test/LdoDataset.test.ts
@ -0,0 +1,168 @@
+import { literal, namedNode, quad } from "@rdfjs/data-model";
+import { createDataset } from "o-dataset-pack";
+import type { SolidProfileShape } from "./profileData";
+import { ProfileShapeType } from "./profileData";
+import type { LdoBuilder, LdoDataset } from "../src";
+import { createLdoDataset, graphOf, parseRdf, toTurtle } from "../src";
+import { sampleJsonld, sampleTurtle } from "./sampleData";
+import type { SubjectProxy } from "jsonld-dataset-proxy";
+import { _proxyContext } from "jsonld-dataset-proxy";
+
+describe("LdoDataset", () => {
+  let ldoDataset: LdoDataset;
+  let profileBuilder: LdoBuilder<SolidProfileShape>;
+
+  beforeEach(async () => {
+    ldoDataset = await parseRdf(sampleTurtle, {
+      baseIRI: "https://solidweb.org/jackson/profile/card",
+    });
+    profileBuilder = ldoDataset.usingType(ProfileShapeType);
+  });
+
+  it("Creates a blank profile", async () => {
+    ldoDataset = createLdoDataset();
+    profileBuilder = ldoDataset.usingType(ProfileShapeType);
+    const profile = profileBuilder.fromSubject(
+      "https://example.com/person1#me",
+    );
+    profile.fn = "Diplo";
+    expect(await toTurtle(profile)).toBe(
+      '<https://example.com/person1#me> <http://www.w3.org/2006/vcard/ns#fn> "Diplo".\n',
+    );
+  });
+
+  it("initializes a profile using the fromJson method", () => {
+    const profile = profileBuilder.fromJson({
+      type: [{ "@id": "Person" }, { "@id": "Person2" }],
+      inbox: { "@id": "https://inbox.com" },
+      fn: "Diplo",
+    });
+    expect(profile.inbox).toEqual({ "@id": "https://inbox.com" });
+    expect(profile.fn).toBe("Diplo");
+    expect(profile["@id"]).toBe(undefined);
+  });
+
+  it("initializes a profile with an id using the fromJson method", () => {
+    const profile = profileBuilder.fromJson({
+      "@id": "https://example.com/person1",
+      type: [{ "@id": "Person" }, { "@id": "Person2" }],
+      inbox: { "@id": "https://inbox.com" },
+      fn: "Diplo",
+    });
+    expect(profile.inbox).toEqual({ "@id": "https://inbox.com" });
+    expect(profile.fn).toBe("Diplo");
+    expect(profile["@id"]).toBe("https://example.com/person1");
+  });
+
+  it("retrieves a subject with a named node", async () => {
+    const profile = await profileBuilder.fromSubject(
+      namedNode("https://solidweb.org/jackson/profile/card#me"),
+    );
+    expect(profile.fn).toBe("Jackson Morgan");
+  });
+
+  it("retrieves a subject with a string id", async () => {
+    const profile = profileBuilder.fromSubject(
+      "https://solidweb.org/jackson/profile/card#me",
+    );
+    expect(profile.fn).toBe("Jackson Morgan");
+  });
+
+  it("uses an existing dataset as the basis for the ldo", async () => {
+    const dataset = createDataset();
+    dataset.add(
+      quad(
+        namedNode("https://example.com/person1"),
+        namedNode("http://xmlns.com/foaf/0.1/name"),
+        literal("Captain cool"),
+      ),
+    );
+    const profile = createLdoDataset(dataset)
+      .usingType(ProfileShapeType)
+      .fromSubject("https://example.com/person1");
+    expect(profile.name).toBe("Captain cool");
+  });
+
+  it("uses an existing array of quads as the basis for the ldo", async () => {
+    const quads = [
+      quad(
+        namedNode("https://example.com/person1"),
+        namedNode("http://xmlns.com/foaf/0.1/name"),
+        literal("Captain cool"),
+      ),
+    ];
+    const profile = createLdoDataset(quads)
+      .usingType(ProfileShapeType)
+      .fromSubject("https://example.com/person1");
+    expect(profile.name).toBe("Captain cool");
+  });
+
+  it("parses JsonLD", async () => {
+    await expect(async () => parseRdf(sampleJsonld)).rejects.toThrow(
+      "Not Implemented",
+    );
+    // ldoDataset = await parseRdf(sampleJsonld);
+    // const profile = ldoDataset
+    //   .usingType(ProfileShapeType)
+    //   .fromSubject("https://example.com/item");
+    // expect(profile.name).toBe("Captain of Coolness");
+  });
+
+  it("parses an existing dataset", async () => {
+    const ldoDataset = await parseRdf(createDataset());
+    expect(typeof ldoDataset.usingType).toBe("function");
+  });
+
+  it("Sets the proper write graphs", () => {
+    const profile = profileBuilder
+      .write("https://example.com/exampleGraph")
+      .fromSubject("https://example.com/person1");
+    profile.name = "Jackson";
+    expect(graphOf(profile, "name")[0].value).toBe(
+      "https://example.com/exampleGraph",
+    );
+  });
+
+  it("Lets a match query retrieve subjects", () => {
+    const profiles = profileBuilder.matchSubject(
+      "http://www.w3.org/1999/02/22-rdf-syntax-ns#type",
+      "http://xmlns.com/foaf/0.1/Person",
+    );
+    expect(profiles[0].fn).toBe("Jackson Morgan");
+  });
+
+  it("Handles alternate optionality for subject match", () => {
+    const profiles = profileBuilder.matchSubject(
+      undefined,
+      undefined,
+      "https://someGraph.com",
+    );
+    expect(profiles.length).toBe(0);
+  });
+
+  it("Lets a match query retrieve objects", () => {
+    const profiles = profileBuilder.matchObject(
+      null,
+      "http://xmlns.com/foaf/0.1/primaryTopic",
+    );
+    expect(profiles[0].fn).toBe("Jackson Morgan");
+  });
+
+  it("Handles alternate optionality for object match", () => {
+    const profiles = profileBuilder.matchObject(
+      "https://someSubject",
+      undefined,
+      "https://someGraph.com",
+    );
+    expect(profiles.length).toBe(0);
+  });
+
+  it("Sets language preferences", () => {
+    const profile = profileBuilder
+      .setLanguagePreferences("@none", "en")
+      .fromSubject("https://solidweb.org/jackson/profile/card#me");
+    expect(
+      (profile as unknown as SubjectProxy)[_proxyContext].languageOrdering,
+    ).toEqual(["@none", "en"]);
+  });
+});
--- a/packages/ldo/test/methods.test.ts
+++ b/packages/ldo/test/methods.test.ts
@ -0,0 +1,151 @@
+import { namedNode } from "@rdfjs/data-model";
+import type { SubjectProxy } from "jsonld-dataset-proxy";
+import {
+  getProxyFromObject,
+  graphOf,
+  _getUnderlyingDataset,
+  _proxyContext,
+} from "jsonld-dataset-proxy";
+import { createDataset } from "o-dataset-pack";
+import type { SolidProfileShape } from "./profileData";
+import { ProfileShapeType } from "./profileData";
+import type { LdoDataset } from "../src";
+import {
+  commitTransaction,
+  createLdoDataset,
+  getDataset,
+  serialize,
+  startTransaction,
+  toJsonLd,
+  toNTriples,
+  toSparqlUpdate,
+  toTurtle,
+  transactionChanges,
+  write,
+  setLanguagePreferences,
+  languagesOf,
+} from "../src";
+
+describe("methods", () => {
+  let dataset: LdoDataset;
+  let profile: SolidProfileShape;
+  beforeEach(() => {
+    dataset = createLdoDataset();
+    profile = dataset
+      .usingType(ProfileShapeType)
+      .fromSubject(namedNode("https://example.com/item"));
+  });
+
+  it("Records changes in a transaction", () => {
+    startTransaction(profile);
+    profile.name = "Beeboo";
+    const changes = transactionChanges(profile);
+    expect(changes.added?.size).toBe(1);
+    expect(changes.removed).toBe(undefined);
+  });
+
+  it("throws when called with startTransaction if an underlying dataset is not a subscribable dataset", () => {
+    const proxy = getProxyFromObject(profile);
+    proxy[_proxyContext] = proxy[_proxyContext].duplicate({
+      dataset: createDataset(),
+    });
+    expect(() => startTransaction(profile)).toThrow(
+      "Object is not transactable.",
+    );
+  });
+
+  it("Commits changes", () => {
+    startTransaction(profile);
+    profile.name = "Joey";
+    expect(dataset.size).toBe(0);
+    commitTransaction(profile);
+    expect(dataset.size).toBe(1);
+    expect(profile.name).toBe("Joey");
+  });
+
+  it("throws an error if transaction dependent functions are called without a transaction", async () => {
+    expect(() => transactionChanges(profile)).toThrow(
+      "Object is not currently in a transaction",
+    );
+    expect(() => commitTransaction(profile)).toThrow(
+      "Object is not currently in a transaction",
+    );
+    await expect(async () => toSparqlUpdate(profile)).rejects.toThrow(
+      "Object is not currently in a transaction",
+    );
+  });
+
+  it("provides the correct sparql update", async () => {
+    profile.name = "Mr. Cool Dude";
+    startTransaction(profile);
+    profile.name = "Captain of Coolness";
+    expect(await toSparqlUpdate(profile)).toBe(
+      `DELETE DATA { <https://example.com/item> <http://xmlns.com/foaf/0.1/name> "Mr. Cool Dude" .  }; INSERT DATA { <https://example.com/item> <http://xmlns.com/foaf/0.1/name> "Captain of Coolness" .  }`,
+    );
+  });
+
+  it("provides a sparql update when nothing has been changed", async () => {
+    startTransaction(profile);
+    expect(await toSparqlUpdate(profile)).toBe("");
+  });
+
+  it("translates into turtle", async () => {
+    profile.name = "Captain of Coolness";
+    expect(await toTurtle(profile)).toBe(
+      '<https://example.com/item> <http://xmlns.com/foaf/0.1/name> "Captain of Coolness".\n',
+    );
+  });
+
+  it("translates into n-triples", async () => {
+    profile.name = "Captain of Coolness";
+    expect(await toNTriples(profile)).toBe(
+      '<https://example.com/item> <http://xmlns.com/foaf/0.1/name> "Captain of Coolness" .\n',
+    );
+  });
+
+  it("uses the serialize method", async () => {
+    profile.name = "Captain of Coolness";
+    expect(await serialize(profile, { format: "Turtle" })).toBe(
+      '<https://example.com/item> <http://xmlns.com/foaf/0.1/name> "Captain of Coolness".\n',
+    );
+  });
+
+  it.skip("translates into jsonld", async () => {
+    profile.name = "Captain of Coolness";
+    expect(await toJsonLd(profile)).toEqual([
+      {
+        "@id": "https://example.com/item",
+        "http://xmlns.com/foaf/0.1/name": "Captain of Coolness",
+      },
+    ]);
+  });
+
+  it("errors when asked to convert to JsonLd", async () => {
+    await expect(async () => toJsonLd(profile)).rejects.toThrow(
+      "Not Implemented",
+    );
+  });
+
+  it("returns the underlying dataset", () => {
+    const underlyingDataset = getDataset(profile);
+    expect(typeof underlyingDataset.add).toBe("function");
+  });
+
+  it("sets a write graph", () => {
+    write("https://graphname.com").using(profile);
+    profile.name = "Jackson";
+    expect(graphOf(profile, "name")[0].value).toBe("https://graphname.com");
+  });
+
+  it("sets the language preferences", () => {
+    setLanguagePreferences("@none", "en").using(profile);
+    expect(
+      (profile as unknown as SubjectProxy)[_proxyContext].languageOrdering,
+    ).toEqual(["@none", "en"]);
+  });
+
+  it("uses languagesOf", () => {
+    const result = languagesOf(profile, "name");
+    expect(result).toEqual({});
+  });
+});
--- a/packages/ldo/test/profileData.ts
+++ b/packages/ldo/test/profileData.ts
--- a/packages/ldo/test/sampleData.ts
+++ b/packages/ldo/test/sampleData.ts
@ -0,0 +1,16 @@
+export const sampleTurtle = `
+  <https://solidweb.me/jackson/profile/card> a <http://xmlns.com/foaf/0.1/PersonalProfileDocument>;
+      <http://xmlns.com/foaf/0.1/maker> <#me>;
+      <http://xmlns.com/foaf/0.1/primaryTopic> <#me>.
+  <#me> a <http://xmlns.com/foaf/0.1/Person>;
+      <http://www.w3.org/ns/solid/terms#oidcIssuer> <https://solidweb.me/>;
+      <http://www.w3.org/2006/vcard/ns#fn> "Jackson Morgan";
+      <http://www.w3.org/2006/vcard/ns#hasEmail> <#id1651115504716>.
+  `;
+
+export const sampleJsonld = [
+  {
+    "@id": "https://example.com/item",
+    "http://xmlns.com/foaf/0.1/name": [{ "@value": "Captain of Coolness" }],
+  },
+];
--- a/packages/schema-converter-shex/.eslintrc
+++ b/packages/schema-converter-shex/.eslintrc
@ -0,0 +1,3 @@
+{
+  "extends": ["../../.eslintrc"]
+}
--- a/packages/schema-converter-shex/README.md
+++ b/packages/schema-converter-shex/README.md
@ -0,0 +1,120 @@
+# ShexJ 2 Type and Context
+
+Turn ShexJ into typescript typings and JSON-LD context.
+
+## Installation
+```bash
+npm i @ldo/schema-converter-shex
+```
+
+## API
+See the [full API docs](docs/modules.md).
+
+## Usage
+
+```typescript
+import { Schema } from "shexj";
+import shexjToTypeAndContext from "@ldo/schema-converter-shex";
+
+async function run() {
+  /**
+   * Sample ShexJ. Equivalent to:
+   *
+   * <EmployeeShape> {                # An <EmployeeShape> has:
+   *   foaf:givenName  xsd:string+,   # at least one givenName.
+   *   foaf:familyName xsd:string,    # one familyName.
+   *   foaf:phone      IRI*,          # any number of phone numbers.
+   *   foaf:mbox       IRI            # one FOAF mbox.
+   * }
+   */
+  const sampleShexj: Schema = {
+    type: "Schema",
+    shapes: [
+      {
+        type: "Shape",
+        id: "http://shex.io/webapps/shex.js/doc/EmployeeShape",
+        expression: {
+          type: "EachOf",
+          expressions: [
+            {
+              type: "TripleConstraint",
+              predicate: "http://xmlns.com/foaf/0.1/givenName",
+              valueExpr: {
+                type: "NodeConstraint",
+                datatype: "http://www.w3.org/2001/XMLSchema#string",
+              },
+              min: 1,
+              max: -1,
+            },
+            {
+              type: "TripleConstraint",
+              predicate: "http://xmlns.com/foaf/0.1/familyName",
+              valueExpr: {
+                type: "NodeConstraint",
+                datatype: "http://www.w3.org/2001/XMLSchema#string",
+              },
+            },
+            {
+              type: "TripleConstraint",
+              predicate: "http://xmlns.com/foaf/0.1/phone",
+              valueExpr: {
+                type: "NodeConstraint",
+                nodeKind: "iri",
+              },
+              min: 0,
+              max: -1,
+            },
+            {
+              type: "TripleConstraint",
+              predicate: "http://xmlns.com/foaf/0.1/mbox",
+              valueExpr: {
+                type: "NodeConstraint",
+                nodeKind: "iri",
+              },
+            },
+          ],
+        },
+      },
+    ],
+    "@context": "http://www.w3.org/ns/shex.jsonld",
+  };
+
+  const [typings, context] = await shexjToTypeAndContext(sampleShexj);
+
+  /*
+  Logs:
+  declare namespace  {
+    interface EmployeeShape {
+        givenName: string[];
+        familyName: string;
+        phone?: string[];
+        mbox: string;
+    }
+
+  }
+  */
+  console.log(typings.typingsString);
+  /*
+  Logs:
+  {
+    givenName: {
+      '@id': 'http://xmlns.com/foaf/0.1/givenName',
+      '@type': 'http://www.w3.org/2001/XMLSchema#string',
+      '@container': '@set'
+    },
+    familyName: {
+      '@id': 'http://xmlns.com/foaf/0.1/familyName',
+      '@type': 'http://www.w3.org/2001/XMLSchema#string'
+    },
+    phone: { '@id': 'http://xmlns.com/foaf/0.1/phone', '@container': '@set' },
+    mbox: { '@id': 'http://xmlns.com/foaf/0.1/mbox' }
+  }
+  */
+  console.log(context);
+}
+run();
+```
+
+
+## Liscense
+MIT
--- a/packages/schema-converter-shex/jest.config.js
+++ b/packages/schema-converter-shex/jest.config.js
@ -0,0 +1,5 @@
+const sharedConfig = require('../../jest.config.js');
+module.exports = {
+  ...sharedConfig,
+  'rootDir': './',
+}
--- a/packages/schema-converter-shex/package.json
+++ b/packages/schema-converter-shex/package.json
@ -0,0 +1,40 @@
+{
+  "name": "@ldo/schema-converter-shex",
+  "version": "0.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "test": "jest --coverage",
+    "prepublishOnly": "npm run test && npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/o-development/shexj2typeandcontext.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/o-development/shexj2typeandcontext/issues"
+  },
+  "homepage": "https://github.com/o-development/shexj2typeandcontextr#readme",
+  "devDependencies": {
+    "@shexjs/parser": "^1.0.0-alpha.24",
+    "@types/jest": "^27.0.3",
+    "@types/jsonld": "^1.5.6",
+    "@types/shexj": "^2.1.3",
+    "jest": "^27.4.5",
+    "jsonld": "^5.2.0",
+    "o-dataset-pack": "^0.2.1",
+    "shex-test": "^2.1.0",
+    "ts-jest": "^27.1.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "dts-dom": "^3.6.0",
+    "jsonld2graphobject": "^0.0.5",
+    "shexj-traverser": "^2.0.1"
+  }
+}
--- a/packages/schema-converter-shex/src/context/JsonLdContextBuilder.ts
+++ b/packages/schema-converter-shex/src/context/JsonLdContextBuilder.ts
@ -0,0 +1,182 @@
+import { Annotation } from "shexj";
+import { ContextDefinition, ExpandedTermDefinition } from "jsonld";
+
+/**
+ * Name functions
+ */
+export function iriToName(iri: string): string {
+  try {
+    const url = new URL(iri);
+    if (url.hash) {
+      return url.hash.slice(1);
+    } else {
+      const splitPathname = url.pathname.split("/");
+      return splitPathname[splitPathname.length - 1];
+    }
+  } catch (err) {
+    return iri;
+  }
+}
+
+export function nameFromObject(obj: {
+  id?: string;
+  annotations?: Annotation[];
+}): string | undefined {
+  const labelAnnotationObject = obj.annotations?.find(
+    (annotation) =>
+      annotation.predicate === "http://www.w3.org/2000/01/rdf-schema#label"
+  )?.object;
+  if (labelAnnotationObject && typeof labelAnnotationObject === "string") {
+    return toCamelCase(iriToName(labelAnnotationObject));
+  } else if (
+    labelAnnotationObject &&
+    typeof labelAnnotationObject !== "string"
+  ) {
+    return toCamelCase(labelAnnotationObject.value);
+  } else if (obj.id) {
+    return toCamelCase(iriToName(obj.id));
+  }
+}
+
+export function toCamelCase(text: string) {
+  return text
+    .replace(/([-_ ]){1,}/g, " ")
+    .split(/[-_ ]/)
+    .reduce((cur, acc) => {
+      return cur + acc[0].toUpperCase() + acc.substring(1);
+    });
+}
+
+/**
+ * JsonLd Context Builder
+ */
+export class JsonLdContextBuilder {
+  private iriAnnotations: Record<string, Annotation[]> = {};
+  private iriTypes: Record<string, ExpandedTermDefinition> = {};
+  private generatedNames: Record<string, string> | undefined;
+
+  addSubject(iri: string, annotations?: Annotation[]) {
+    if (!this.iriAnnotations[iri]) {
+      this.iriAnnotations[iri] = [];
+    }
+    if (annotations && annotations.length > 0) {
+      this.iriAnnotations[iri].push(...annotations);
+    }
+  }
+
+  addPredicate(
+    iri: string,
+    expandedTermDefinition: ExpandedTermDefinition,
+    isContainer: boolean,
+    annotations?: Annotation[]
+  ) {
+    this.addSubject(iri, annotations);
+    if (!this.iriTypes[iri]) {
+      this.iriTypes[iri] = expandedTermDefinition;
+      if (isContainer) {
+        this.iriTypes[iri]["@container"] = "@set";
+      }
+    } else {
+      const curDef = this.iriTypes[iri];
+      const newDef = expandedTermDefinition;
+      // TODO: if you reuse the same predicate with a different cardinality,
+      // it will overwrite the past cardinality. Perhapse we might want to
+      // split contexts in the various shapes.
+      if (isContainer) {
+        curDef["@container"] = "@set";
+      }
+      // If the old and new versions both have types
+      if (curDef["@type"] && newDef["@type"]) {
+        if (
+          Array.isArray(curDef["@type"]) &&
+          !(curDef["@type"] as string[]).includes(newDef["@type"])
+        ) {
+          curDef["@type"].push(newDef["@type"]);
+        } else if (
+          typeof curDef["@type"] === "string" &&
+          curDef["@type"] !== newDef["@type"]
+        ) {
+          // The typings are incorrect. String arrays are allowed on @type
+          // see https://w3c.github.io/json-ld-syntax/#example-specifying-multiple-types-for-a-node
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          curDef["@type"] = [curDef["@type"], newDef["@type"]];
+        }
+      }
+    }
+  }
+
+  generateNames(): Record<string, string> {
+    const generatedNames: Record<string, string> = {};
+    const claimedNames: Set<string> = new Set();
+    Object.entries(this.iriAnnotations).forEach(([iri, annotations]) => {
+      let potentialName: string | undefined;
+      if (annotations.length > 0) {
+        const labelAnnotationObject = annotations.find(
+          (annotation) =>
+            annotation.predicate ===
+            "http://www.w3.org/2000/01/rdf-schema#label"
+        )?.object;
+        if (
+          labelAnnotationObject &&
+          typeof labelAnnotationObject === "string"
+        ) {
+          potentialName = toCamelCase(iriToName(labelAnnotationObject));
+        } else if (
+          labelAnnotationObject &&
+          typeof labelAnnotationObject !== "string"
+        ) {
+          potentialName = toCamelCase(labelAnnotationObject.value);
+        }
+      }
+      if (!potentialName) {
+        potentialName = toCamelCase(iriToName(iri));
+      }
+      if (claimedNames.has(potentialName)) {
+        let i = 2;
+        let newName: string | undefined;
+        do {
+          if (!claimedNames.has(`${potentialName}${i}`)) {
+            newName = `${potentialName}${i}`;
+          }
+          i++;
+        } while (!newName);
+        potentialName = newName;
+      }
+      claimedNames.add(potentialName);
+      generatedNames[iri] = potentialName;
+    });
+    return generatedNames;
+  }
+
+  getNameFromIri(iri: string) {
+    if (!this.generatedNames) {
+      this.generatedNames = this.generateNames();
+    }
+    if (this.generatedNames[iri]) {
+      return this.generatedNames[iri];
+    } else {
+      return iri;
+    }
+  }
+
+  generateJsonldContext(): ContextDefinition {
+    const contextDefnition: ContextDefinition = {};
+    const namesMap = this.generateNames();
+    Object.entries(namesMap).forEach(([iri, name]) => {
+      if (this.iriTypes[iri]) {
+        contextDefnition[name] = {
+          "@id":
+            iri === "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+              ? "@type"
+              : iri,
+          ...this.iriTypes[iri],
+        };
+      } else {
+        contextDefnition[name] = iri;
+      }
+    });
+
+    return contextDefnition;
+  }
+}
--- a/packages/schema-converter-shex/src/context/ShexJContextVisitor.ts
+++ b/packages/schema-converter-shex/src/context/ShexJContextVisitor.ts
@ -0,0 +1,83 @@
+import ShexJTraverser from "shexj-traverser";
+import { JsonLdContextBuilder } from "./JsonLdContextBuilder";
+
+/**
+ * Visitor
+ */
+export const ShexJNameVisitor =
+  ShexJTraverser.createVisitor<JsonLdContextBuilder>({
+    Shape: {
+      visitor: async (shape, context) => {
+        
+      }
+    },
+    TripleConstraint: {
+      visitor: async (tripleConstraint, context) => {
+        if (tripleConstraint.valueExpr) {
+          const isContainer =
+            tripleConstraint.max !== undefined && tripleConstraint.max !== 1;
+          if (typeof tripleConstraint.valueExpr === "string") {
+            // TOOD handle string value expr
+          } else if (tripleConstraint.valueExpr.type === "NodeConstraint") {
+            if (tripleConstraint.valueExpr.datatype) {
+              context.addPredicate(
+                tripleConstraint.predicate,
+                {
+                  "@type": tripleConstraint.valueExpr.datatype,
+                },
+                isContainer,
+                tripleConstraint.annotations
+              );
+            } else if (
+              tripleConstraint.valueExpr.nodeKind &&
+              tripleConstraint.valueExpr.nodeKind !== "literal"
+            ) {
+              context.addPredicate(
+                tripleConstraint.predicate,
+                { "@type": "@id" },
+                isContainer,
+                tripleConstraint.annotations
+              );
+            } else {
+              context.addPredicate(
+                tripleConstraint.predicate,
+                {},
+                isContainer,
+                tripleConstraint.annotations
+              );
+            }
+          } else {
+            context.addPredicate(
+              tripleConstraint.predicate,
+              {
+                "@type": "@id",
+              },
+              isContainer,
+              tripleConstraint.annotations
+            );
+          }
+        } else {
+          context.addSubject(
+            tripleConstraint.predicate,
+            tripleConstraint.annotations
+          );
+        }
+      },
+    },
+    NodeConstraint: {
+      visitor: async (nodeConstraint, context) => {
+        if (nodeConstraint.values) {
+          nodeConstraint.values.forEach((value) => {
+            if (typeof value === "string") {
+              context.addSubject(value);
+            }
+          });
+        }
+      },
+    },
+    IriStem: {
+      visitor: async (iriStem, context) => {
+        context.addSubject(iriStem.stem);
+      },
+    },
+  });
--- a/packages/schema-converter-shex/src/context/shexjToContext.ts
+++ b/packages/schema-converter-shex/src/context/shexjToContext.ts
@ -0,0 +1,21 @@
+import { ContextDefinition } from "jsonld";
+import { Schema } from "shexj";
+import { JsonLdContextBuilder } from "./JsonLdContextBuilder";
+import { ShexJNameVisitor } from "./ShexJContextVisitor";
+import { jsonld2graphobject } from "jsonld2graphobject";
+
+export async function shexjToContext(
+  shexj: Schema
+): Promise<ContextDefinition> {
+  const processedShexj: Schema = (await jsonld2graphobject(
+    {
+      ...shexj,
+      "@id": "SCHEMA",
+      "@context": "http://www.w3.org/ns/shex.jsonld",
+    },
+    "SCHEMA"
+  )) as unknown as Schema;
+  const jsonLdContextBuilder = new JsonLdContextBuilder();
+  await ShexJNameVisitor.visit(processedShexj, "Schema", jsonLdContextBuilder);
+  return jsonLdContextBuilder.generateJsonldContext();
+}
--- a/packages/schema-converter-shex/src/index.ts
+++ b/packages/schema-converter-shex/src/index.ts
@ -0,0 +1,3 @@
+import { shexjToTyping } from "./typing/shexjToTyping";
+
+export default shexjToTyping;
--- a/packages/schema-converter-shex/src/typing/ShapeInterfaceDeclaration.ts
+++ b/packages/schema-converter-shex/src/typing/ShapeInterfaceDeclaration.ts
@ -0,0 +1,5 @@
+import { InterfaceDeclaration } from "dts-dom";
+
+export interface ShapeInterfaceDeclaration extends InterfaceDeclaration {
+  shapeId?: string;
+}
--- a/packages/schema-converter-shex/src/typing/ShexJTypingTransformer.ts
+++ b/packages/schema-converter-shex/src/typing/ShexJTypingTransformer.ts
@ -0,0 +1,355 @@
+import ShexJTraverser from "shexj-traverser";
+import * as dom from "dts-dom";
+import { Annotation } from "shexj";
+import { nameFromObject } from "../context/JsonLdContextBuilder";
+import { ShapeInterfaceDeclaration } from "./ShapeInterfaceDeclaration";
+
+export interface ShexJTypeTransformerContext {
+  getNameFromIri: (iri: string) => string;
+}
+
+export function commentFromAnnotations(
+  annotations?: Annotation[]
+): string | undefined {
+  const commentAnnotationObject = annotations?.find(
+    (annotation) =>
+      annotation.predicate === "http://www.w3.org/2000/01/rdf-schema#comment"
+  )?.object;
+  if (typeof commentAnnotationObject === "string") {
+    // It's an IRI
+    return commentAnnotationObject;
+  } else {
+    return commentAnnotationObject?.value;
+  }
+}
+
+export const ShexJTypingTransformer = ShexJTraverser.createTransformer<
+  {
+    Schema: {
+      return: dom.TopLevelDeclaration[];
+    };
+    ShapeDecl: {
+      return: dom.InterfaceDeclaration;
+    };
+    Shape: {
+      return: dom.InterfaceDeclaration;
+    };
+    EachOf: {
+      return: dom.ObjectType | dom.InterfaceDeclaration;
+    };
+    TripleConstraint: {
+      return: dom.PropertyDeclaration;
+    };
+    NodeConstraint: {
+      return: dom.Type;
+    };
+  },
+  ShexJTypeTransformerContext
+>({
+  Schema: {
+    transformer: async (
+      _schema,
+      getTransformedChildren
+    ): Promise<dom.TopLevelDeclaration[]> => {
+      const transformedChildren = await getTransformedChildren();
+      const interfaces: dom.TopLevelDeclaration[] = [];
+      transformedChildren.shapes?.forEach((shape) => {
+        if (
+          typeof shape !== "string" &&
+          (shape as dom.InterfaceDeclaration).kind === "interface"
+        ) {
+          interfaces.push(shape as dom.InterfaceDeclaration);
+        }
+      });
+      return interfaces;
+    },
+  },
+  ShapeDecl: {
+    transformer: async (
+      shapeDecl,
+      getTransformedChildren
+    ): Promise<dom.InterfaceDeclaration> => {
+      const shapeName = nameFromObject(shapeDecl) || "Shape";
+      const { shapeExpr } = await getTransformedChildren();
+      if ((shapeExpr as dom.InterfaceDeclaration).kind === "interface") {
+        const shapeInterface = shapeExpr as ShapeInterfaceDeclaration;
+        shapeInterface.name = shapeName;
+        // This exists so the LDO-CLI can understand which type corresponds to the shape
+        shapeInterface.shapeId = shapeDecl.id;
+        return shapeInterface;
+      } else {
+        // TODO: Handle other items
+        throw new Error(
+          "Cannot handle ShapeOr, ShapeAnd, ShapeNot, ShapeExternal, or NodeConstraint"
+        );
+      }
+    },
+  },
+  Shape: {
+    transformer: async (shape, getTransformedChildren, setReturnPointer) => {
+      const newInterface: ShapeInterfaceDeclaration = dom.create.interface("");
+      setReturnPointer(newInterface);
+      const transformedChildren = await getTransformedChildren();
+      // Add @id and @context
+      newInterface.members.push(
+        dom.create.property(
+          "@id",
+          dom.type.string,
+          dom.DeclarationFlags.Optional
+        )
+      );
+      newInterface.members.push(
+        dom.create.property(
+          "@context",
+          dom.create.namedTypeReference("ContextDefinition"),
+          dom.DeclarationFlags.Optional
+        )
+      );
+      if (typeof transformedChildren.expression === "string") {
+        // TODO: handle string
+      } else if (
+        (transformedChildren.expression as dom.ObjectType).kind === "object" ||
+        (transformedChildren.expression as dom.InterfaceDeclaration).kind ===
+          "interface"
+      ) {
+        newInterface.members.push(
+          ...(transformedChildren.expression as dom.ObjectType).members
+        );
+      } else if (
+        (transformedChildren.expression as dom.PropertyDeclaration).kind ===
+        "property"
+      ) {
+        newInterface.members.push(
+          transformedChildren.expression as dom.PropertyDeclaration
+        );
+      }
+      // Use EXTENDS
+      if (transformedChildren.extends) {
+        newInterface.baseTypes = [];
+        transformedChildren.extends.forEach((extendsItem) => {
+          if ((extendsItem as dom.InterfaceDeclaration).kind === "interface") {
+            newInterface.baseTypes?.push(
+              extendsItem as dom.InterfaceDeclaration
+            );
+          }
+        });
+      }
+      return newInterface;
+    },
+  },
+  EachOf: {
+    transformer: async (eachOf, getTransformedChildren, setReturnPointer) => {
+      const transformedChildren = await getTransformedChildren();
+      const name = nameFromObject(eachOf);
+      const objectType = name
+        ? dom.create.interface(name)
+        : dom.create.objectType([]);
+      const eachOfComment = commentFromAnnotations(eachOf.annotations);
+      setReturnPointer(objectType);
+      // Get Input property expressions
+      const inputPropertyExpressions: dom.PropertyDeclaration[] = [];
+      transformedChildren.expressions
+        .filter(
+          (
+            expression
+          ): expression is dom.ObjectType | dom.PropertyDeclaration => {
+            return (
+              (expression as dom.PropertyDeclaration).kind === "property" ||
+              (expression as dom.ObjectType).kind === "object" ||
+              (expression as dom.InterfaceDeclaration).kind === "interface"
+            );
+          }
+        )
+        .forEach(
+          (
+            expression:
+              | dom.ObjectType
+              | dom.InterfaceDeclaration
+              | dom.PropertyDeclaration
+          ) => {
+            if (expression.kind === "property") {
+              inputPropertyExpressions.push(expression);
+            } else {
+              expression.members.forEach((objectMember) => {
+                if (objectMember.kind === "property") {
+                  inputPropertyExpressions.push(objectMember);
+                }
+              });
+            }
+          }
+        );
+
+      // Merge property expressions
+      const properties: Record<string, dom.PropertyDeclaration> = {};
+      inputPropertyExpressions.forEach((expression) => {
+        const propertyDeclaration = expression as dom.PropertyDeclaration;
+        // Combine properties if they're duplicates
+        if (properties[propertyDeclaration.name]) {
+          const oldPropertyDeclaration = properties[propertyDeclaration.name];
+          const oldPropertyTypeAsArray =
+            oldPropertyDeclaration.type as dom.ArrayTypeReference;
+          const oldProeprtyType =
+            oldPropertyTypeAsArray.kind === "array"
+              ? oldPropertyTypeAsArray.type
+              : oldPropertyDeclaration.type;
+          const propertyTypeAsArray =
+            propertyDeclaration.type as dom.ArrayTypeReference;
+          const propertyType =
+            propertyTypeAsArray.kind === "array"
+              ? propertyTypeAsArray.type
+              : propertyDeclaration.type;
+          const isOptional =
+            propertyDeclaration.flags === dom.DeclarationFlags.Optional ||
+            oldPropertyDeclaration.flags === dom.DeclarationFlags.Optional;
+          properties[propertyDeclaration.name] = dom.create.property(
+            propertyDeclaration.name,
+            dom.type.array(dom.create.union([oldProeprtyType, propertyType])),
+            isOptional
+              ? dom.DeclarationFlags.Optional
+              : dom.DeclarationFlags.None
+          );
+          // Set JS Comment
+          properties[propertyDeclaration.name].jsDocComment =
+            oldPropertyDeclaration.jsDocComment &&
+            propertyDeclaration.jsDocComment
+              ? `${oldPropertyDeclaration.jsDocComment} | ${propertyDeclaration.jsDocComment}`
+              : oldPropertyDeclaration.jsDocComment ||
+                propertyDeclaration.jsDocComment ||
+                eachOfComment;
+        } else {
+          properties[propertyDeclaration.name] = propertyDeclaration;
+        }
+      });
+      objectType.members.push(...Object.values(properties));
+      return objectType;
+    },
+  },
+  TripleConstraint: {
+    transformer: async (
+      tripleConstraint,
+      getTransformedChildren,
+      setReturnPointer,
+      context
+    ) => {
+      const transformedChildren = await getTransformedChildren();
+      const propertyName = context.getNameFromIri(tripleConstraint.predicate);
+      const isArray =
+        tripleConstraint.max !== undefined && tripleConstraint.max !== 1;
+      const isOptional = tripleConstraint.min === 0;
+      let type: dom.Type = dom.type.any;
+      if (transformedChildren.valueExpr) {
+        type = transformedChildren.valueExpr as dom.Type;
+      }
+
+      const propertyDeclaration = dom.create.property(
+        propertyName,
+        isArray ? dom.type.array(type) : type,
+        isOptional ? dom.DeclarationFlags.Optional : dom.DeclarationFlags.None
+      );
+
+      propertyDeclaration.jsDocComment = commentFromAnnotations(
+        tripleConstraint.annotations
+      );
+      return propertyDeclaration;
+    },
+  },
+  NodeConstraint: {
+    transformer: async (
+      nodeConstraint,
+      _getTransformedChildren,
+      setReturnPointer,
+      context
+    ) => {
+      if (nodeConstraint.datatype) {
+        switch (nodeConstraint.datatype) {
+          case "http://www.w3.org/2001/XMLSchema#string":
+          case "http://www.w3.org/2001/XMLSchema#ENTITIES":
+          case "http://www.w3.org/2001/XMLSchema#ENTITY":
+          case "http://www.w3.org/2001/XMLSchema#ID":
+          case "http://www.w3.org/2001/XMLSchema#IDREF":
+          case "http://www.w3.org/2001/XMLSchema#IDREFS":
+          case "http://www.w3.org/2001/XMLSchema#language":
+          case "http://www.w3.org/2001/XMLSchema#Name":
+          case "http://www.w3.org/2001/XMLSchema#NCName":
+          case "http://www.w3.org/2001/XMLSchema#NMTOKEN":
+          case "http://www.w3.org/2001/XMLSchema#NMTOKENS":
+          case "http://www.w3.org/2001/XMLSchema#normalizedString":
+          case "http://www.w3.org/2001/XMLSchema#QName":
+          case "http://www.w3.org/2001/XMLSchema#token":
+            return dom.type.string;
+          case "http://www.w3.org/2001/XMLSchema#date":
+          case "http://www.w3.org/2001/XMLSchema#dateTime":
+          case "http://www.w3.org/2001/XMLSchema#duration":
+          case "http://www.w3.org/2001/XMLSchema#gDay":
+          case "http://www.w3.org/2001/XMLSchema#gMonth":
+          case "http://www.w3.org/2001/XMLSchema#gMonthDay":
+          case "http://www.w3.org/2001/XMLSchema#gYear":
+          case "http://www.w3.org/2001/XMLSchema#gYearMonth":
+          case "http://www.w3.org/2001/XMLSchema#time":
+            return dom.type.string;
+          case "http://www.w3.org/2001/XMLSchema#byte":
+          case "http://www.w3.org/2001/XMLSchema#decimal":
+          case "http://www.w3.org/2001/XMLSchema#int":
+          case "http://www.w3.org/2001/XMLSchema#integer":
+          case "http://www.w3.org/2001/XMLSchema#long":
+          case "http://www.w3.org/2001/XMLSchema#negativeInteger":
+          case "http://www.w3.org/2001/XMLSchema#nonNegativeInteger":
+          case "http://www.w3.org/2001/XMLSchema#nonPositiveInteger":
+          case "http://www.w3.org/2001/XMLSchema#positiveInteger":
+          case "http://www.w3.org/2001/XMLSchema#short":
+          case "http://www.w3.org/2001/XMLSchema#unsignedLong":
+          case "http://www.w3.org/2001/XMLSchema#unsignedInt":
+          case "http://www.w3.org/2001/XMLSchema#unsignedShort":
+          case "http://www.w3.org/2001/XMLSchema#unsignedByte":
+            return dom.type.number;
+          case "http://www.w3.org/2001/XMLSchema#boolean":
+            return dom.type.boolean;
+          case "http://www.w3.org/2001/XMLSchema#hexBinary":
+            return dom.type.string;
+          case "http://www.w3.org/2001/XMLSchema#anyURI":
+            return dom.type.string;
+          default:
+            return dom.type.string;
+        }
+      }
+      if (nodeConstraint.nodeKind) {
+        switch (nodeConstraint.nodeKind) {
+          case "iri":
+            return dom.create.objectType([
+              dom.create.property("@id", dom.type.string),
+            ]);
+          case "bnode":
+            return dom.create.objectType([]);
+          case "nonliteral":
+            return dom.create.objectType([
+              dom.create.property(
+                "@id",
+                dom.type.string,
+                dom.DeclarationFlags.Optional
+              ),
+            ]);
+          case "literal":
+          default:
+            return dom.type.string;
+        }
+      }
+      if (nodeConstraint.values) {
+        const valuesUnion = dom.create.union([]);
+        nodeConstraint.values.forEach((value) => {
+          if (typeof value === "string") {
+            valuesUnion.members.push(
+              dom.create.objectType([
+                dom.create.property(
+                  "@id",
+                  dom.type.stringLiteral(context.getNameFromIri(value))
+                ),
+              ])
+            );
+          }
+        });
+        return valuesUnion;
+      }
+      return dom.type.undefined;
+    },
+  },
+});
--- a/packages/schema-converter-shex/src/typing/shexjToTyping.ts
+++ b/packages/schema-converter-shex/src/typing/shexjToTyping.ts
@ -0,0 +1,59 @@
+import { ContextDefinition } from "jsonld";
+import { Schema } from "shexj";
+import { JsonLdContextBuilder } from "../context/JsonLdContextBuilder";
+import { ShexJNameVisitor } from "../context/ShexJContextVisitor";
+import { jsonld2graphobject } from "jsonld2graphobject";
+import { ShexJTypingTransformer } from "./ShexJTypingTransformer";
+import * as dom from "dts-dom";
+
+export interface TypeingReturn {
+  typingsString: string;
+  typings: {
+    typingString: string;
+    dts: dom.TopLevelDeclaration;
+  }[];
+}
+
+export async function shexjToTyping(
+  shexj: Schema
+): Promise<[TypeingReturn, ContextDefinition]> {
+  const processedShexj: Schema = (await jsonld2graphobject(
+    {
+      ...shexj,
+      "@id": "SCHEMA",
+      "@context": "http://www.w3.org/ns/shex.jsonld",
+    },
+    "SCHEMA"
+  )) as unknown as Schema;
+  const jsonLdContextBuilder = new JsonLdContextBuilder();
+  await ShexJNameVisitor.visit(processedShexj, "Schema", jsonLdContextBuilder);
+
+  const declarations = await ShexJTypingTransformer.transform(
+    processedShexj,
+    "Schema",
+    {
+      getNameFromIri:
+        jsonLdContextBuilder.getNameFromIri.bind(jsonLdContextBuilder),
+    }
+  );
+  const typings = declarations.map((declaration) => {
+    return {
+      typingString: dom
+        .emit(declaration, {
+          rootFlags: dom.ContextFlags.InAmbientNamespace,
+        })
+        .replace("\r\n", "\n"),
+      dts: declaration,
+    };
+  });
+  const typingsString =
+    `import {ContextDefinition} from "jsonld"\n\n` +
+    typings.map((typing) => `export ${typing.typingString}`).join("");
+
+  const typeingReturn: TypeingReturn = {
+    typingsString,
+    typings,
+  };
+
+  return [typeingReturn, jsonLdContextBuilder.generateJsonldContext()];
+}
--- a/packages/schema-converter-shex/test/context.test.ts
+++ b/packages/schema-converter-shex/test/context.test.ts
@ -0,0 +1,16 @@
+import { testData } from "./testData/testData";
+import { shexjToContext } from "../src/context/shexjToContext";
+import parser from "@shexjs/parser";
+import type { Schema } from "shexj";
+
+describe("context", () => {
+  testData.forEach(({ name, shexc, successfulContext }) => {
+    it(`Creates a context for ${name}`, async () => {
+      const schema: Schema = parser
+        .construct("https://ldo.js.org/")
+        .parse(shexc);
+      const context = await shexjToContext(schema);
+      expect(context).toEqual(successfulContext);
+    });
+  });
+});
--- a/packages/schema-converter-shex/test/testData/activityPub.ts
+++ b/packages/schema-converter-shex/test/testData/activityPub.ts
--- a/packages/schema-converter-shex/test/testData/circular.ts
+++ b/packages/schema-converter-shex/test/testData/circular.ts
@ -0,0 +1,42 @@
+import type { TestData } from "./testData";
+
+/**
+ * Circular
+ */
+export const circular: TestData = {
+  name: "circular",
+  shexc: `
+  PREFIX example: <http://example.com/> 
+
+  example:ParentShape {
+    a [ example:Parent ]? ;
+    example:hasChild @example:ChildShape ;
+  }
+
+  example:ChildShape {
+    a [ example:Child ]? ;
+    example:hasParent @example:ParentShape ;
+  }
+  `,
+  sampleTurtle: `
+    @prefix example: <http://example.com/> .
+
+    example:SampleParent
+      a example:Parent ;
+      example:hasChild example:SampleChild .
+
+    example:SampleChild
+      a example:Child ;
+      example:hasParent example:SampleParent .
+  `,
+  baseNode: "http://example.com/SampleParent",
+  successfulContext: {
+    type: { "@id": "@type" },
+    Parent: "http://example.com/Parent",
+    hasChild: { "@id": "http://example.com/hasChild", "@type": "@id" },
+    Child: "http://example.com/Child",
+    hasParent: { "@id": "http://example.com/hasParent", "@type": "@id" },
+  },
+  successfulTypings:
+    'import {ContextDefinition} from "jsonld"\n\nexport interface ParentShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    type?: {\r\n        "@id": "Parent";\r\n    };\r\n    hasChild: ChildShape;\r\n}\r\n\r\nexport interface ChildShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    type?: {\r\n        "@id": "Child";\r\n    };\r\n    hasParent: ParentShape;\r\n}\r\n\r\n',
+};
--- a/packages/schema-converter-shex/test/testData/extendsSimple.ts
+++ b/packages/schema-converter-shex/test/testData/extendsSimple.ts
@ -0,0 +1,43 @@
+import type { TestData } from "./testData";
+
+/**
+ * Circular
+ */
+export const extendsSimple: TestData = {
+  name: "extends simple",
+  shexc: `
+  PREFIX ex: <https://example.com/>
+  PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+
+  ex:EntityShape {
+    ex:entityId .
+  }
+
+  ex:PersonShape EXTENDS @ex:EntityShape {
+    foaf:name .
+  }
+
+  ex:EmployeeShape EXTENDS @ex:PersonShape {
+    ex:employeeNumber .
+  }
+  `,
+  sampleTurtle: `
+    @prefix example: <http://example.com/> .
+
+    example:SampleParent
+      a example:Parent ;
+      example:hasChild example:SampleChild .
+
+    example:SampleChild
+      a example:Child ;
+      example:hasParent example:SampleParent .
+  `,
+  baseNode: "http://example.com/SampleParent",
+  successfulContext: {
+    entityId: "https://example.com/entityId",
+    name: "http://xmlns.com/foaf/0.1/name",
+    employeeNumber: "https://example.com/employeeNumber",
+  },
+  successfulTypings:
+    'import {ContextDefinition} from "jsonld"\n\nexport interface EntityShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    entityId: any;\r\n}\r\n\r\nexport interface PersonShapeextends EntityShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    name: any;\r\n}\r\n\r\nexport interface EmployeeShapeextends PersonShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    employeeNumber: any;\r\n}\r\n\r\n',
+};
--- a/packages/schema-converter-shex/test/testData/oldExtends.ts
+++ b/packages/schema-converter-shex/test/testData/oldExtends.ts
@ -0,0 +1,48 @@
+import type { TestData } from "./testData";
+
+/**
+ * Circular
+ */
+export const oldExtends: TestData = {
+  name: "old extends",
+  shexc: `
+  PREFIX ex: <https://example.com/>
+  PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+
+  ex:EntityShape {
+    $ex:EntityRef (
+      ex:entityId .
+    )
+  }
+
+  ex:PersonShape {
+    $ex:PersonRef (
+      &ex:EntityRef ;
+      foaf:name .
+    )
+  }
+
+  ex:EmployeeShape EXTENDS @ex:PersonShape {
+    &ex:PersonRef ;
+    ex:employeeNumber .
+  }
+  `,
+  sampleTurtle: `
+    @prefix ex: <http://example.com/> .
+    @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+    @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+    ex:SampleEmployee
+      ex:entityId "123"^^xsd:integer ;
+      foaf:name "Jacko" ;
+      ex:employeeNumber "456"^^xsd:integer ;
+  `,
+  baseNode: "http://example.com/SampleParent",
+  successfulContext: {
+    entityId: "https://example.com/entityId",
+    name: "http://xmlns.com/foaf/0.1/name",
+    employeeNumber: "https://example.com/employeeNumber",
+  },
+  successfulTypings:
+    'import {ContextDefinition} from "jsonld"\n\nexport interface EntityShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    entityId: any;\r\n}\r\n\r\nexport interface PersonShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    entityId: any;\r\n    name: any;\r\n}\r\n\r\nexport interface EmployeeShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    entityId: any;\r\n    name: any;\r\n    employeeNumber: any;\r\n}\r\n\r\n',
+};
--- a/packages/schema-converter-shex/test/testData/profile.ts
+++ b/packages/schema-converter-shex/test/testData/profile.ts
--- a/packages/schema-converter-shex/test/testData/reducedProfile.ts
+++ b/packages/schema-converter-shex/test/testData/reducedProfile.ts
@ -0,0 +1,81 @@
+import type { TestData } from "./testData";
+
+/**
+ * Reduced Profile
+ */
+export const reducedProfile: TestData = {
+  name: "reduced profile",
+  shexc: `
+PREFIX srs: <https://shaperepo.com/schemas/solidProfile#>
+PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+PREFIX schem: <http://schema.org/>
+PREFIX vcard: <http://www.w3.org/2006/vcard/ns#>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+PREFIX acl: <http://www.w3.org/ns/auth/acl#>
+PREFIX cert:  <http://www.w3.org/ns/auth/cert#>
+PREFIX ldp: <http://www.w3.org/ns/ldp#>
+PREFIX sp: <http://www.w3.org/ns/pim/space#>
+PREFIX solid: <http://www.w3.org/ns/solid/terms#>
+
+srs:SolidProfileShape EXTRA a {
+  a [ schem:Person ]
+    // rdfs:comment  "Defines the node as a Person" ;
+  a [ foaf:Person ]
+    // rdfs:comment  "Defines the node as a Person" ;
+  vcard:hasEmail @srs:EmailShape *
+    // rdfs:comment  "The person's email." ;
+  foaf:name xsd:string ?
+    // rdfs:comment  "An alternate way to define a person's name" ;
+}
+
+srs:EmailShape EXTRA a {
+  a [
+    vcard:Dom
+    vcard:Home
+    vcard:ISDN
+    vcard:Internet
+    vcard:Intl
+    vcard:Label
+    vcard:Parcel
+    vcard:Postal
+    vcard:Pref
+    vcard:Work
+    vcard:X400
+  ] ?
+    // rdfs:comment  "The type of email." ;
+  vcard:value IRI
+    // rdfs:comment  "The value of an email as a mailto link (Example <mailto:jane@example.com>)" ;
+}
+  `,
+  sampleTurtle: ``,
+  baseNode: "",
+  successfulContext: {
+    type: { "@id": "@type" },
+    Person: "http://schema.org/Person",
+    Person2: "http://xmlns.com/foaf/0.1/Person",
+    hasEmail: {
+      "@id": "http://www.w3.org/2006/vcard/ns#hasEmail",
+      "@type": "@id",
+      "@container": "@set",
+    },
+    Dom: "http://www.w3.org/2006/vcard/ns#Dom",
+    Home: "http://www.w3.org/2006/vcard/ns#Home",
+    ISDN: "http://www.w3.org/2006/vcard/ns#ISDN",
+    Internet: "http://www.w3.org/2006/vcard/ns#Internet",
+    Intl: "http://www.w3.org/2006/vcard/ns#Intl",
+    Label: "http://www.w3.org/2006/vcard/ns#Label",
+    Parcel: "http://www.w3.org/2006/vcard/ns#Parcel",
+    Postal: "http://www.w3.org/2006/vcard/ns#Postal",
+    Pref: "http://www.w3.org/2006/vcard/ns#Pref",
+    Work: "http://www.w3.org/2006/vcard/ns#Work",
+    X400: "http://www.w3.org/2006/vcard/ns#X400",
+    value: { "@id": "http://www.w3.org/2006/vcard/ns#value", "@type": "@id" },
+    name: {
+      "@id": "http://xmlns.com/foaf/0.1/name",
+      "@type": "http://www.w3.org/2001/XMLSchema#string",
+    },
+  },
+  successfulTypings:
+    'import {ContextDefinition} from "jsonld"\n\nexport interface SolidProfileShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    /**\r\n     * Defines the node as a Person | Defines the node as a Person\r\n     */\r\n    type: ({\r\n        "@id": "Person";\r\n    } | {\r\n        "@id": "Person2";\r\n    })[];\r\n    /**\r\n     * The person\'s email.\r\n     */\r\n    hasEmail?: (EmailShape)[];\r\n    /**\r\n     * An alternate way to define a person\'s name\r\n     */\r\n    name?: string;\r\n}\r\n\r\nexport interface EmailShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    /**\r\n     * The type of email.\r\n     */\r\n    type?: {\r\n        "@id": "Dom";\r\n    } | {\r\n        "@id": "Home";\r\n    } | {\r\n        "@id": "ISDN";\r\n    } | {\r\n        "@id": "Internet";\r\n    } | {\r\n        "@id": "Intl";\r\n    } | {\r\n        "@id": "Label";\r\n    } | {\r\n        "@id": "Parcel";\r\n    } | {\r\n        "@id": "Postal";\r\n    } | {\r\n        "@id": "Pref";\r\n    } | {\r\n        "@id": "Work";\r\n    } | {\r\n        "@id": "X400";\r\n    };\r\n    /**\r\n     * The value of an email as a mailto link (Example <mailto:jane@example.com>)\r\n     */\r\n    value: {\r\n        "@id": string;\r\n    };\r\n}\r\n\r\n',
+};
--- a/packages/schema-converter-shex/test/testData/reusedPredicates.ts
+++ b/packages/schema-converter-shex/test/testData/reusedPredicates.ts
@ -0,0 +1,60 @@
+import type { TestData } from "./testData";
+
+/**
+ * Reused Predicate
+ */
+export const reusedPredicates: TestData = {
+  name: "reused predicates",
+  shexc: `
+  PREFIX app:   <https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#>
+  PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+  PREFIX xsd:   <http://www.w3.org/2001/XMLSchema#>
+
+  app:DocumentShape {
+    rdf:type [ app:Document ] ;
+    app:vocabulary @app:VocabularyShape* ;
+    app:law @app:LawShape ;
+  }
+
+  app:LawShape {
+    rdf:type [ app:Law ] ;
+    app:name xsd:string ;
+    app:path IRI ;
+  }
+
+  app:VocabularyShape {
+    rdf:type [ app:Vocabulary ] ;
+    app:name xsd:string ;
+    app:path IRI ;
+  }
+  `,
+  sampleTurtle: ``,
+  baseNode: "http://example.com/SampleParent",
+  successfulContext: {
+    type: { "@id": "@type" },
+    Document: "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#Document",
+    vocabulary: {
+      "@id":
+        "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#vocabulary",
+      "@type": "@id",
+      "@container": "@set",
+    },
+    Vocabulary:
+      "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#Vocabulary",
+    name: {
+      "@id": "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#name",
+      "@type": "http://www.w3.org/2001/XMLSchema#string",
+    },
+    path: {
+      "@id": "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#path",
+      "@type": "@id",
+    },
+    law: {
+      "@id": "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#law",
+      "@type": "@id",
+    },
+    Law: "https://www.forsakringskassan.se/vocabs/fk-sem-poc.ttl#Law",
+  },
+  successfulTypings:
+    'import {ContextDefinition} from "jsonld"\n\nexport interface DocumentShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    type: {\r\n        "@id": "Document";\r\n    };\r\n    vocabulary?: (VocabularyShape)[];\r\n    law: LawShape;\r\n}\r\n\r\nexport interface LawShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    type: {\r\n        "@id": "Law";\r\n    };\r\n    name: string;\r\n    path: {\r\n        "@id": string;\r\n    };\r\n}\r\n\r\nexport interface VocabularyShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    type: {\r\n        "@id": "Vocabulary";\r\n    };\r\n    name: string;\r\n    path: {\r\n        "@id": string;\r\n    };\r\n}\r\n\r\n',
+};
--- a/packages/schema-converter-shex/test/testData/simple.ts
+++ b/packages/schema-converter-shex/test/testData/simple.ts
@ -0,0 +1,50 @@
+import type { TestData } from "./testData";
+
+/**
+ * SIMPLE
+ */
+export const simple: TestData = {
+  name: "simple",
+  shexc: `
+  PREFIX foaf: <http://xmlns.com/foaf/0.1/>
+  PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+  PREFIX example: <https://example.com/>
+
+  example:EmployeeShape {                # An <EmployeeShape> has:
+    foaf:givenName  xsd:string+,   # at least one givenName.
+    foaf:familyName xsd:string,    # one familyName.
+    foaf:phone      IRI*,          # any number of phone numbers.
+    foaf:mbox       IRI            # one FOAF mbox.
+  }
+  `,
+  sampleTurtle: `
+    @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+    @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+    <http://a.example/Employee7>
+      foaf:givenName  "Robert"^^xsd:string, "Taylor"^^xsd:string ;
+      foaf:familyName "Johnson"^^xsd:string ;
+      # no phone number needed
+      foaf:mbox       <mailto:rtj@example.com>
+      .
+  `,
+  baseNode: "http://a.example/Employee7",
+  successfulContext: {
+    givenName: {
+      "@id": "http://xmlns.com/foaf/0.1/givenName",
+      "@type": "http://www.w3.org/2001/XMLSchema#string",
+      "@container": "@set",
+    },
+    familyName: {
+      "@id": "http://xmlns.com/foaf/0.1/familyName",
+      "@type": "http://www.w3.org/2001/XMLSchema#string",
+    },
+    phone: {
+      "@id": "http://xmlns.com/foaf/0.1/phone",
+      "@type": "@id",
+      "@container": "@set",
+    },
+    mbox: { "@id": "http://xmlns.com/foaf/0.1/mbox", "@type": "@id" },
+  },
+  successfulTypings:
+    'import {ContextDefinition} from "jsonld"\n\nexport interface EmployeeShape {\n    "@id"?: string;\r\n    "@context"?: ContextDefinition;\r\n    givenName: string[];\r\n    familyName: string;\r\n    phone?: {\r\n        "@id": string;\r\n    }[];\r\n    mbox: {\r\n        "@id": string;\r\n    };\r\n}\r\n\r\n',
+};
--- a/packages/schema-converter-shex/test/testData/testData.ts
+++ b/packages/schema-converter-shex/test/testData/testData.ts
@ -0,0 +1,29 @@
+import type { ContextDefinition } from "jsonld";
+import { activityPub } from "./activityPub";
+import { circular } from "./circular";
+import { profile } from "./profile";
+import { reducedProfile } from "./reducedProfile";
+import { simple } from "./simple";
+import { extendsSimple } from "./extendsSimple";
+import { reusedPredicates } from "./reusedPredicates";
+// import { oldExtends } from "./oldExtends";
+
+export interface TestData {
+  name: string;
+  shexc: string;
+  sampleTurtle: string;
+  baseNode: string;
+  successfulContext: ContextDefinition;
+  successfulTypings: string;
+}
+
+export const testData: TestData[] = [
+  simple,
+  circular,
+  profile,
+  reducedProfile,
+  activityPub,
+  extendsSimple,
+  // oldExtends,
+  reusedPredicates,
+];
--- a/packages/schema-converter-shex/test/typing.test.ts
+++ b/packages/schema-converter-shex/test/typing.test.ts
@ -0,0 +1,16 @@
+import parser from "@shexjs/parser";
+import { testData } from "./testData/testData";
+import { shexjToTyping } from "../src/typing/shexjToTyping";
+import type { Schema } from "shexj";
+
+describe("typing", () => {
+  testData.forEach(({ name, shexc, successfulTypings }) => {
+    it(`Creates a typings for ${name}`, async () => {
+      const schema: Schema = parser
+        .construct("https://ldo.js.org/")
+        .parse(shexc);
+      const [typings] = await shexjToTyping(schema);
+      expect(typings.typingsString).toBe(successfulTypings);
+    });
+  });
+});
--- a/packages/schema-converter-shex/tsconfig.build.json
+++ b/packages/schema-converter-shex/tsconfig.build.json
@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist"
+  },
+  "include": ["./src"]
+}