@ng-org/shex-orm 0.1.2-alpha.6 → 0.1.2-alpha.8

package/README.md

@@ -23,11 +23,11 @@ npx rdf-orm build --input ./src/shapes/shex --output ./src/shapes/orm
 The input directory needs to contain shex files with one or more shape definitions each, for example:
 
 ```shex
-PREFIX ex: <http://example.org/>
+PREFIX ex: <did:ng:z:>
 PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
 
 ex:ExpenseShape {
-  a [ex:Person] ;                  # Required type <http://example.org/Person>
+  a [ex:Person] ;                  # Required type <did:ng:z:Person>
   ex:name xsd:string ;             # Required string
   ex:email xsd:string * ;          # Zero or more strings (set)
   ex:height xsd:float ;            # Required number

package/dist/schema-converter/__tests__/schemaTransformer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=schemaTransformer.test.d.ts.map

package/dist/schema-converter/__tests__/schemaTransformer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemaTransformer.test.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/__tests__/schemaTransformer.test.ts"],"names":[],"mappings":""}

package/dist/schema-converter/__tests__/schemaTransformer.test.js

@@ -0,0 +1,209 @@
+import { describe, it, expect } from "vitest";
+import parser from "@shexjs/parser";
+import annotateReadablePredicates from "../util/annotateReadablePredicates.js";
+import { shexJConverter } from "../converter.js";
+// Generated with Claude Opus 4.6
+const TYPE_IRI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+const BASE_IRI = "http://example.org/";
+/** Parse ShEx text → ShExJ → annotate → convert → return flattened schema. */
+async function buildSchema(shex) {
+    // @ts-ignore
+    const shexJ = parser.construct(BASE_IRI).parse(shex);
+    // @ts-ignore
+    annotateReadablePredicates(shexJ);
+    const [, schema] = await shexJConverter(shexJ);
+    return schema;
+}
+/** Find a predicate by its IRI in a shape. */
+function findPredicate(shape, predicateIri) {
+    return shape.predicates.find((p) => p.iri === predicateIri);
+}
+// ---------------------------------------------------------------------------
+// Common prefixes used in all test schemas
+// ---------------------------------------------------------------------------
+const PREFIXES = `
+PREFIX ex: <http://example.org/>
+PREFIX xsd: <http://www.w3.org/2001/XMLSchema#>
+`;
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("ShexJSchemaTransformer", () => {
+    // Single shape reference via @
+    it("converts a single @-prefixed shape reference to valType 'shape'", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category @ex:CategoryShape ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(1);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "shape",
+            shape: "http://example.org/CategoryShape",
+        });
+    });
+    // Shape reference without @ (datatype-like IRI) → valType "iri"
+    it("converts an unrecognized datatype IRI to valType 'iri'", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category ex:CategoryShape ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(1);
+        expect(pred.dataTypes[0].valType).toBe("iri");
+    });
+    // ShapeOr with multiple shape references
+    it("converts ShapeOr with two shape references to two shape DataTypes", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category (@ex:CategoryShape OR @ex:TagShape) ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+            ex:TagShape EXTRA a {
+                a [ ex:Tag ] ;
+                ex:label xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(2);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "shape",
+            shape: "http://example.org/CategoryShape",
+        });
+        expect(pred.dataTypes[1]).toEqual({
+            valType: "shape",
+            shape: "http://example.org/TagShape",
+        });
+    });
+    // ShapeOr mixing primitive and shape reference
+    it("converts ShapeOr mixing a primitive and a shape reference", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:catOrString xsd:string OR @ex:CategoryShape ;
+            }
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/catOrString");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(2);
+        const types = pred.dataTypes.map((d) => d.valType);
+        expect(types).toContain("string");
+        expect(types).toContain("shape");
+        const shapeDt = pred.dataTypes.find((d) => d.valType === "shape");
+        expect(shapeDt.shape).toBe("http://example.org/CategoryShape");
+    });
+    // Anonymous inline shape → flattened to root with derived IRI
+    it("flattens anonymous inline shapes to root with a derived IRI", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:category EXTRA a {
+                    a [ ex:Category ] ;
+                    ex:name xsd:string ;
+                } ;
+            }
+        `);
+        const derivedIri = "http://example.org/ItemShape||http://example.org/category";
+        // The parent predicate should reference the derived IRI
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/category");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(1);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "shape",
+            shape: derivedIri,
+        });
+        // The anonymous shape should exist as a root-level entry
+        const flattenedShape = schema[derivedIri];
+        expect(flattenedShape).toBeDefined();
+        expect(flattenedShape.iri).toBe(derivedIri);
+        const namePred = findPredicate(flattenedShape, "http://example.org/name");
+        expect(namePred).toBeDefined();
+    });
+    // IRI value set (enumeration)
+    it("converts IRI value sets to multiple iri DataTypes with literals", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+                ex:status [ex:Active ex:Archived ex:Deleted] ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        const pred = findPredicate(item, "http://example.org/status");
+        expect(pred).toBeDefined();
+        expect(pred.dataTypes).toHaveLength(3);
+        expect(pred.dataTypes[0]).toEqual({
+            valType: "iri",
+            literals: ["http://example.org/Active"],
+        });
+        expect(pred.dataTypes[1]).toEqual({
+            valType: "iri",
+            literals: ["http://example.org/Archived"],
+        });
+        expect(pred.dataTypes[2]).toEqual({
+            valType: "iri",
+            literals: ["http://example.org/Deleted"],
+        });
+    });
+    // Single-predicate shape (no EachOf wrapper)
+    it("handles shapes with only one predicate", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:ItemShape {
+                ex:name xsd:string ;
+            }
+        `);
+        const item = schema["http://example.org/ItemShape"];
+        expect(item).toBeDefined();
+        expect(item.predicates).toHaveLength(1);
+        expect(item.predicates[0].iri).toBe("http://example.org/name");
+        expect(item.predicates[0].dataTypes[0].valType).toBe("string");
+    });
+    // EXTRA predicate
+    it("marks EXTRA predicates with extra: true", async () => {
+        const schema = await buildSchema(`
+            ${PREFIXES}
+            ex:CategoryShape EXTRA a {
+                a [ ex:Category ] ;
+                ex:name xsd:string ;
+            }
+        `);
+        const cat = schema["http://example.org/CategoryShape"];
+        const typePred = findPredicate(cat, TYPE_IRI);
+        expect(typePred).toBeDefined();
+        expect(typePred.extra).toBe(true);
+    });
+});

package/dist/schema-converter/templates/schema.ejs

@@ -5,4 +5,4 @@ import type { Schema } from "@ng-org/shex-orm";
 * <%- fileName %>Schema: Schema for <%- fileName %>
                 * =============================================================================
                 */
-                export const <%- fileName %>Schema: Schema = <%- compactSchema %>;
+                export const <%- fileName %>Schema = <%- compactSchema %> as const satisfies Schema;

package/dist/schema-converter/templates/shapeTypes.ejs

@@ -1,14 +1,15 @@
 import type { ShapeType } from "@ng-org/shex-orm";
-import { <%- fileName %>Schema } from "./<%- fileName %>.schema";
+import { <%- fileName %>Schema } from "./<%- fileName %>.schema.ts";
     import type {
     <% typings.forEach((typing)=> { if (!/Id$/.test(typing.dts.name)) { -%>
       <%- typing.dts.name %>,
-        <% } }); -%>} from "./<%- fileName %>.typings";
+        <% } }); -%>} from "./<%- fileName %>.typings.ts";
 
             // ShapeTypes for <%- fileName %>
               <% typings.forEach((typing)=> { if (!/Id$/.test(typing.dts.name)) { -%>
-                export const <%- typing.dts.name %>ShapeType: ShapeType<<%- typing.dts.name %>> = {
-                    schema: <%- fileName %>Schema,
-                      shape: "<%- typing.dts.shapeId %>",
-                        };
+                export const <%- typing.dts.name %>ShapeType = {
+                  schema: <%- fileName %>Schema,
+                    shape: "<%- typing.dts.shapeId %>",
+                      } as const satisfies ShapeType<<%- typing.dts.name %>>;
+
                         <% } }); -%>

package/dist/schema-converter/transformers/ShexJSchemaTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShexJSchemaTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJSchemaTransformer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAyDjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,KAAK,EAAE,CAAA;KAAE;eAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;WACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;YAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;sBACP;QAAE,MAAM,EAAE,SAAS,CAAA;KAAE;oBACvB;QAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;KAAE;aACxC;QAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;KAAE;cACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;cACjB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QA+OtC,CAAC"}
+{"version":3,"file":"ShexJSchemaTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJSchemaTransformer.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAyDjE,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,KAAK,EAAE,CAAA;KAAE;eAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;WACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;YAChB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;sBACP;QAAE,MAAM,EAAE,SAAS,CAAA;KAAE;oBACvB;QAAE,MAAM,EAAE,QAAQ,GAAG,QAAQ,EAAE,CAAA;KAAE;aACxC;QAAE,MAAM,EAAE,QAAQ,EAAE,CAAA;KAAE;cACrB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;cACjB;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QAgRtC,CAAC"}

package/dist/schema-converter/transformers/ShexJSchemaTransformer.js

@@ -59,7 +59,7 @@ const rdfDataTypeToBasic = (dataType) => {
         case "http://www.w3.org/2001/XMLSchema#anyURI":
             return "iri";
         default:
-            return "string";
+            return "iri";
     }
 };
 export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
@@ -81,7 +81,12 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
             // TODO: We don't handles those
             _shape.closed;
             const transformedChildren = await getTransformedChildren();
-            const compactShape = transformedChildren.expression;
+            const expr = transformedChildren.expression;
+            // EachOf returns a Shape ({ iri, predicates }), but a single
+            // TripleConstraint returns a bare Predicate. Normalize both.
+            const compactShape = expr && "predicates" in expr
+                ? expr
+                : { iri: "", predicates: [expr] };
             for (const extra of _shape.extra || []) {
                 const extraPredicate = compactShape.predicates.find((p) => p.iri === extra);
                 if (extraPredicate)
@@ -128,12 +133,25 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
             }
             else if (transformedChildren.valueExpr &&
                 transformedChildren.valueExpr.predicates) {
-                // Nested object
+                const resolvedShape = transformedChildren.valueExpr;
+                if (resolvedShape.iri) {
+                    // Named shape reference: Use the IRI string.
+                    return {
+                        dataTypes: [
+                            {
+                                valType: "shape",
+                                shape: resolvedShape.iri,
+                            },
+                        ],
+                        ...commonProperties,
+                    };
+                }
+                // Anonymous inline shape: Pass as shape object for flattenSchema to convert.
                 return {
                     dataTypes: [
                         {
                             valType: "shape",
-                            shape: transformedChildren.valueExpr,
+                            shape: resolvedShape, // Make type fit as any (object will be flattened).
                         },
                     ],
                     ...commonProperties,
@@ -248,7 +266,24 @@ export const ShexJSchemaTransformerCompact = ShexJTraverser.createTransformer({
             // or a DataType[] (from NodeConstraint with multiple types).
             // We need to flatten arrays to get a single DataType[].
             const exprs = Array.isArray(shapeExprs) ? shapeExprs : [shapeExprs];
-            return exprs.flatMap((expr) => Array.isArray(expr) ? expr : [expr]);
+            return exprs.flatMap((expr) => {
+                if (Array.isArray(expr))
+                    return expr;
+                // Resolved shape reference: Convert to DataType with shape IRI.
+                if (expr && typeof expr === "object" && "predicates" in expr) {
+                    return [
+                        {
+                            valType: "shape",
+                            shape: expr.iri,
+                        },
+                    ];
+                }
+                // String shape reference
+                if (typeof expr === "string") {
+                    return [{ valType: "shape", shape: expr }];
+                }
+                return [expr];
+            });
         },
     },
     // Transformer from ShapeAnd

package/dist/schema-converter/transformers/ShexJTypingTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShexJTypingTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJTypingTransformer.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,eAAO,MAAM,4BAA4B,aAAoB,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7D;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAOvC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAc7C;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC9B,GAAG,MAAM,GAAG,SAAS,CAgBrB;AAyPD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAA;KAAE;eAClC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;WACxC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;YACnC;QAAE,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,oBAAoB,CAAA;KAAE;sBAC3C;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,CAAA;KAAE;oBACrC;QAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAA;KAAE;aAC3B;QAAE,MAAM,EAAE,GAAG,CAAC,SAAS,CAAA;KAAE;cACxB;QAAE,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAA;KAAE;cAChC;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QAwctC,CAAC"}
+{"version":3,"file":"ShexJTypingTransformer.d.ts","sourceRoot":"","sources":["../../../src/schema-converter/transformers/ShexJTypingTransformer.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACxC,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAC/B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,MAAM,WAAW,yBAA0B,SAAQ,oBAAoB;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAGD,eAAO,MAAM,4BAA4B,aAAoB,CAAC;AAE9D,MAAM,WAAW,yBAAyB;IACtC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7D;AAeD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAOvC;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE;IACxC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,WAAW,CAAC,EAAE,UAAU,EAAE,CAAC;CAC9B,GAAG,MAAM,GAAG,SAAS,CAgBrB;AAyPD,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAE1B;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,EAAE,CAAA;KAAE;eAClC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;WACxC;QAAE,MAAM,EAAE,GAAG,CAAC,oBAAoB,CAAA;KAAE;YACnC;QAAE,MAAM,EAAE,GAAG,CAAC,UAAU,GAAG,GAAG,CAAC,oBAAoB,CAAA;KAAE;sBAC3C;QAAE,MAAM,EAAE,GAAG,CAAC,mBAAmB,CAAA;KAAE;oBACrC;QAAE,MAAM,EAAE,GAAG,CAAC,IAAI,CAAA;KAAE;aAC3B;QAAE,MAAM,EAAE,GAAG,CAAC,SAAS,CAAA;KAAE;cACxB;QAAE,MAAM,EAAE,GAAG,CAAC,gBAAgB,CAAA;KAAE;cAChC;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;mBACZ;QAAE,MAAM,EAAE,KAAK,CAAA;KAAE;QAketC,CAAC"}

package/dist/schema-converter/transformers/ShexJTypingTransformer.js

@@ -32,21 +32,9 @@ export function toCamelCase(text) {
  * Name functions
  */
 export function iriToName(iri) {
-    try {
-        const url = new URL(iri);
-        let name;
-        if (url.hash) {
-            name = url.hash.slice(1);
-        }
-        else {
-            const splitPathname = url.pathname.split("/");
-            name = splitPathname[splitPathname.length - 1];
-        }
-        return name.replace(/(?<!^)Shape$/, "");
-    }
-    catch (err) {
-        return iri;
-    }
+    const lastSegment = iri.split(/[\/:#?@&=]/).at(-1);
+    // Remove *Shape part of name, if it exists.
+    return lastSegment.replace(/(?<!^)Shape$/, "");
 }
 export function nameFromAnnotationOrId(obj) {
     const labelAnnotationObject = obj.annotations?.find((annotation) => annotation.predicate ===
@@ -536,6 +524,31 @@ export const ShexJTypingTransformerCompact = ShexJTraverser.createTransformer({
         transformer: async (nodeConstraint) => {
             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":
+                    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":
+                    case "http://www.w3.org/2001/XMLSchema#hexBinary":
+                        return dom.type.string;
                     case "http://www.w3.org/2001/XMLSchema#boolean":
                         return dom.type.boolean;
                     case "http://www.w3.org/2001/XMLSchema#byte":
@@ -556,7 +569,7 @@ export const ShexJTypingTransformerCompact = ShexJTraverser.createTransformer({
                     case "http://www.w3.org/2001/XMLSchema#unsignedByte":
                         return dom.type.number;
                     default:
-                        return dom.type.string; // treat most as string
+                        return dom.create.namedTypeReference("IRI"); // treat others / references as IRI
                 }
             }
             if (nodeConstraint.nodeKind) {

package/dist/types.d.ts

@@ -26,9 +26,9 @@ export interface Shape {
 /** An allowed data type or literal. */
 export type DataType = {
     /** The required literal value(s). Additional values are allowed, if `extra` is true. */
-    literals?: number[] | string[] | boolean;
-    /** If `valType` is `"shape"`, the nested shape or its reference. Use reference for serialization. */
-    shape?: string | Shape;
+    literals?: number[] | string[] | boolean[];
+    /** If `valType` is `"shape"`, the IRI of the nested shape. */
+    shape?: string;
     /** The type of object value for a triple constraint. */
     valType: "number" | "string" | "boolean" | "iri" | "shape";
 };

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;CAIjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,0BAA0B;AAC1B,MAAM,WAAW,KAAK;IAClB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,uCAAuC;AACvC,MAAM,MAAM,QAAQ,GAAG;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IACzC,qGAAqG;IACrG,KAAK,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IACvB,wDAAwD;IACxD,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC;CAC9D,CAAC;AAEF,gCAAgC;AAChC,MAAM,WAAW,SAAS;IACtB,sFAAsF;IACtF,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,WAAW,SAAS,CAAC,CAAC,SAAS,QAAQ;IACzC,sCAAsC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;CACjB;AAED,6DAA6D;AAC7D,MAAM,WAAW,QAAS,SAAQ,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IACjD,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAC;CAIjB;AAED,MAAM,MAAM,MAAM,GAAG;IACjB,CAAC,EAAE,EAAE,MAAM,GAAG,KAAK,CAAC;CACvB,CAAC;AAEF,0BAA0B;AAC1B,MAAM,WAAW,KAAK;IAClB,iCAAiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,gDAAgD;IAChD,UAAU,EAAE,SAAS,EAAE,CAAC;CAC3B;AAED,uCAAuC;AACvC,MAAM,MAAM,QAAQ,GAAG;IACnB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,EAAE,CAAC;IAC3C,8DAA8D;IAC9D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wDAAwD;IACxD,OAAO,EAAE,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,KAAK,GAAG,OAAO,CAAC;CAC9D,CAAC;AAEF,gCAAgC;AAChC,MAAM,WAAW,SAAS;IACtB,sFAAsF;IACtF,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,6BAA6B;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ng-org/shex-orm",
-  "version": "0.1.2-alpha.6",
+  "version": "0.1.2-alpha.8",
   "description": "",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,9 +18,12 @@
     "@types/fs-extra": "^9.0.13",
     "@types/jsonld": "^1.5.15",
     "@types/shexj": "^2.1.4",
-    "typescript": "^5.9.2",
+    "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
+  "peerDependencies": {
+    "typescript": "^4.9.0 || ^5.0.0 || ^6.0.0"
+  },
   "dependencies": {
     "@ldo/traverser-shexj": "1.0.0-alpha.28",
     "@ldo/type-traverser": "1.0.0-alpha.28",