@ng-org/shex-orm 0.1.2

package/src/schema-converter/util/ShapeInterfaceDeclaration.ts

@@ -0,0 +1,5 @@
+import type { InterfaceDeclaration } from "dts-dom";
+
+export interface ShapeInterfaceDeclaration extends InterfaceDeclaration {
+  shapeId?: string;
+}

package/src/schema-converter/util/annotateReadablePredicates.ts

@@ -0,0 +1,173 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+import type { Schema, ShapeDecl, Shape, EachOf, TripleConstraint } from "shexj";
+
+// Split IRI by colon, slash and hash; drop empties
+const splitIriTokens = (iri: string): string[] =>
+    iri.split(/[:/#]+/).filter(Boolean);
+// Keep dots and dashes (so 0.1 stays as 0.1) but sanitize everything else
+const sanitize = (s: string) => s.replace(/[^\w.\-]/g, "_");
+
+type TCwReadable = TripleConstraint & { readablePredicate?: string };
+
+/**
+ * Annotate EachOf-level TripleConstraints with a collision-free readablePredicate.
+ * Rule: for any group that shares the same local token, rename all members using
+ * prefix-first `${prefix}_${local}` from right to left; fallback to composite.
+ */
+export default function annotateReadablePredicates(schema: Schema): void {
+    const shapes = schema.shapes ?? [];
+
+    const annotateEachOf = (eachOf: EachOf): void => {
+        if (
+            !eachOf ||
+            eachOf.type !== "EachOf" ||
+            !Array.isArray(eachOf.expressions)
+        )
+            return;
+
+        const tcs = (eachOf.expressions as unknown[]).filter(
+            (e): e is TCwReadable =>
+                typeof e === "object" &&
+                e !== null &&
+                (e as any).type === "TripleConstraint"
+        );
+
+        if (tcs.length > 0) {
+            // Group by local token (last segment of IRI) and set a base readablePredicate for all
+            const readableNameToPredicatesMap = new Map<
+                string,
+                TCwReadable[]
+            >();
+            for (const tripleConstraint of tcs) {
+                // Use the name based on the IRI ending.
+                let readableName: string;
+                // Special case rdfs:type => @type
+                if (
+                    tripleConstraint.predicate ===
+                    "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"
+                ) {
+                    readableName = "@type";
+                } else {
+                    const tokens = splitIriTokens(tripleConstraint.predicate);
+                    readableName = tokens.length
+                        ? tokens[tokens.length - 1]
+                        : tripleConstraint.predicate;
+                }
+                // default base name for non-colliders
+                tripleConstraint.readablePredicate = readableName;
+                const groupMembers =
+                    readableNameToPredicatesMap.get(readableName) ?? [];
+                groupMembers.push(tripleConstraint);
+                readableNameToPredicatesMap.set(readableName, groupMembers);
+            }
+            // Resolve each group (rename all in collisions)
+            for (const [, groupMembers] of readableNameToPredicatesMap) {
+                if (groupMembers.length <= 1) continue;
+                const used = new Set<string>();
+                const local =
+                    splitIriTokens(groupMembers[0].predicate).slice(-1)[0] ??
+                    "";
+                for (const tc of groupMembers) {
+                    const tokens = splitIriTokens(tc.predicate);
+                    let localIdx = tokens.lastIndexOf(local);
+                    if (localIdx === -1)
+                        localIdx = Math.max(tokens.length - 1, 0);
+                    let prefixIdx = localIdx - 1;
+                    let assigned = false;
+                    while (prefixIdx >= 0) {
+                        const cand = `${sanitize(tokens[prefixIdx])}_${sanitize(
+                            tokens[localIdx]
+                        )}`;
+                        if (!used.has(cand)) {
+                            tc.readablePredicate = cand;
+                            used.add(cand);
+                            assigned = true;
+                            break;
+                        }
+                        prefixIdx -= 1;
+                    }
+                    if (!assigned) {
+                        const iriNoProto = tc.predicate.replace(
+                            /^[a-z]+:\/\//i,
+                            ""
+                        );
+                        const composite = sanitize(
+                            iriNoProto
+                                .split(/[:/#]+/)
+                                .slice(0, -1)
+                                .join("_") || "iri"
+                        );
+                        let cand = `${composite}_${sanitize(tokens[localIdx] || local)}`;
+                        let n = 1;
+                        while (used.has(cand)) cand = `${cand}_${n++}`;
+                        tc.readablePredicate = cand;
+                        used.add(cand);
+                    }
+                }
+            }
+
+            // Recurse into nested valueExpr shapes of each TC
+            for (const tc of tcs) {
+                const ve: any = (tc as any).valueExpr;
+                if (ve && typeof ve === "object") {
+                    const t = (ve as any).type;
+                    if (t === "Shape" && (ve as any).expression)
+                        annotateEachOf((ve as any).expression as EachOf);
+                    else if (t === "EachOf") annotateEachOf(ve as EachOf);
+                    else if (
+                        t === "ShapeOr" &&
+                        Array.isArray((ve as any).shapeExprs)
+                    ) {
+                        for (const sub of (ve as any).shapeExprs)
+                            annotateFromExpr(sub);
+                    } else if (
+                        t === "ShapeAnd" &&
+                        Array.isArray((ve as any).shapeExprs)
+                    ) {
+                        for (const sub of (ve as any).shapeExprs)
+                            annotateFromExpr(sub);
+                    }
+                }
+            }
+        }
+
+        // Also recurse into any inline sub-EachOf/Shape expressions found directly in expressions
+        for (const ex of eachOf.expressions as any[]) {
+            if (ex && typeof ex === "object") annotateFromExpr(ex);
+        }
+    };
+
+    const annotateFromExpr = (expr: any): void => {
+        if (!expr || typeof expr !== "object") return;
+        const t = (expr as any).type;
+        if (t === "Shape" && (expr as any).expression)
+            annotateEachOf((expr as any).expression as EachOf);
+        else if (t === "EachOf") annotateEachOf(expr as EachOf);
+        else if (t === "ShapeOr" && Array.isArray((expr as any).shapeExprs)) {
+            for (const sub of (expr as any).shapeExprs) annotateFromExpr(sub);
+        } else if (
+            t === "ShapeAnd" &&
+            Array.isArray((expr as any).shapeExprs)
+        ) {
+            for (const sub of (expr as any).shapeExprs) annotateFromExpr(sub);
+        } else if (t === "TripleConstraint") {
+            const ve = (expr as any).valueExpr;
+            if (ve && typeof ve === "object") annotateFromExpr(ve);
+        }
+    };
+
+    for (const s of shapes) {
+        const sd = s as ShapeDecl;
+        const shape = (sd.shapeExpr || (sd as any)) as Shape | undefined;
+        if (shape?.expression) annotateFromExpr(shape as any);
+    }
+}

package/src/schema-converter/util/dedupeObjectTypeMembers.ts

@@ -0,0 +1,61 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+import type { ObjectTypeMember } from "dts-dom";
+import * as dom from "dts-dom";
+
+export function dedupeObjectTypeMembers(
+  memberList: ObjectTypeMember[],
+): ObjectTypeMember[] {
+  const properties: Record<string, dom.PropertyDeclaration> = {};
+  memberList.forEach((expression) => {
+    const propertyDeclaration = expression as dom.PropertyDeclaration;
+    // Combine properties if they're duplicates
+    if (properties[propertyDeclaration.name]) {
+      const oldPropertyDeclaration = properties[propertyDeclaration.name];
+      const oldPropertyType = isLdSetType(oldPropertyDeclaration.type)
+        ? oldPropertyDeclaration.type.typeArguments[0]
+        : oldPropertyDeclaration.type;
+      const propertyType = isLdSetType(propertyDeclaration.type)
+        ? propertyDeclaration.type.typeArguments[0]
+        : propertyDeclaration.type;
+      const isOptional =
+        propertyDeclaration.flags === dom.DeclarationFlags.Optional ||
+        oldPropertyDeclaration.flags === dom.DeclarationFlags.Optional;
+      properties[propertyDeclaration.name] = dom.create.property(
+        propertyDeclaration.name,
+        {
+          kind: "name",
+          name: "LdSet",
+          typeArguments: [dom.create.union([oldPropertyType, 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;
+    } else {
+      properties[propertyDeclaration.name] = propertyDeclaration;
+    }
+  });
+  return Object.values(properties);
+}
+
+function isLdSetType(
+  potentialLdSet: dom.Type,
+): potentialLdSet is dom.NamedTypeReference {
+  return (
+    (potentialLdSet as dom.NamedTypeReference).kind === "name" &&
+    (potentialLdSet as dom.NamedTypeReference).name === "LdSet"
+  );
+}

package/src/schema-converter/util/getRdfTypesForTripleConstraint.ts

@@ -0,0 +1,153 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+import type {
+    ShexJTraverserTypes,
+    tripleExprOrRef,
+} from "@ldo/traverser-shexj";
+import type { InterfaceInstanceNode } from "@ldo/type-traverser";
+
+function addRdfTypeFromTripleExpr(
+    tripleExpr: tripleExprOrRef,
+    rdfTypeSet: Set<string>
+) {
+    if (
+        typeof tripleExpr === "object" &&
+        tripleExpr.type === "TripleConstraint" &&
+        tripleExpr.predicate ===
+            "http://www.w3.org/1999/02/22-rdf-syntax-ns#type" &&
+        typeof tripleExpr.valueExpr === "object" &&
+        tripleExpr.valueExpr.type === "NodeConstraint" &&
+        tripleExpr.valueExpr.values
+    ) {
+        tripleExpr.valueExpr.values.forEach((val) => {
+            if (typeof val === "string") rdfTypeSet.add(val);
+            // TODO handle other edge cases like IRIStem
+        });
+    }
+}
+
+function recursivelyGatherTypesFromShapeNodes(
+    shapeNode: InterfaceInstanceNode<
+        ShexJTraverserTypes,
+        "Shape",
+        ShexJTraverserTypes["Shape"]
+    >,
+    rdfTypeSet: Set<string>
+): void {
+    const tripleExpr = shapeNode.instance.expression;
+    if (tripleExpr) addRdfTypeFromTripleExpr(tripleExpr, rdfTypeSet);
+
+    shapeNode.parent("shapeExpr").forEach((parentShapeExpr) => {
+        parentShapeExpr
+            .parent("ShapeDecl", "shapeExpr")
+            .forEach((parentShapeDecl) => {
+                parentShapeDecl
+                    .parent("shapeDeclRef")
+                    .forEach((parentShapeDeclOrRef) => {
+                        parentShapeDeclOrRef
+                            .parent("shapeExprOrRef")
+                            .forEach((parentShapeExprOrRef) => {
+                                parentShapeExprOrRef
+                                    .parent("Shape", "extends")
+                                    .forEach((parentShape) => {
+                                        recursivelyGatherTypesFromShapeNodes(
+                                            parentShape,
+                                            rdfTypeSet
+                                        );
+                                        const childExpressionNode =
+                                            parentShape.child("expression");
+                                        if (!childExpressionNode) return;
+                                        const childEachOf = childExpressionNode
+                                            .child()
+                                            .child();
+                                        if (childEachOf.typeName === "EachOf") {
+                                            recursivelyGatherTypesFromEachOfNodes(
+                                                childEachOf,
+                                                rdfTypeSet
+                                            );
+                                        }
+                                    });
+                            });
+                    });
+            });
+    });
+}
+
+function recursivelyGatherTypesFromEachOfNodes(
+    eachOfNode: InterfaceInstanceNode<
+        ShexJTraverserTypes,
+        "EachOf",
+        ShexJTraverserTypes["EachOf"]
+    >,
+    rdfTypeSet: Set<string>
+): void {
+    const tripleExprs = eachOfNode.instance.expressions;
+    tripleExprs.forEach((tripleExpr) => {
+        addRdfTypeFromTripleExpr(tripleExpr, rdfTypeSet);
+    });
+
+    eachOfNode.parent("tripleExpr").forEach((tripleExprNode) => {
+        const tripleExprOrRefNodes = tripleExprNode.parent("tripleExprOrRef");
+        tripleExprOrRefNodes.forEach((tripleExprOrRdfNode) => {
+            const parentEachOfs = tripleExprOrRdfNode.parent(
+                "EachOf",
+                "expressions"
+            );
+            parentEachOfs.forEach((parentEachOf) => {
+                recursivelyGatherTypesFromEachOfNodes(parentEachOf, rdfTypeSet);
+            });
+            // Deal with shape extends
+            const parentShapes = tripleExprOrRdfNode.parent(
+                "Shape",
+                "expression"
+            );
+            parentShapes.forEach((parentShape) =>
+                recursivelyGatherTypesFromShapeNodes(parentShape, rdfTypeSet)
+            );
+        });
+    });
+}
+
+export function getRdfTypesForTripleConstraint(
+    tripleConstraintNode: InterfaceInstanceNode<
+        ShexJTraverserTypes,
+        "TripleConstraint",
+        ShexJTraverserTypes["TripleConstraint"]
+    >
+): string[] | undefined[] {
+    // Check that there's a triple constraint that is a type at the
+    // same level if there is, use that as an rdfType
+    const rdfTypeSet = new Set<string>();
+    tripleConstraintNode.parent("tripleExpr").forEach((tripleExprParents) => {
+        tripleExprParents
+            .parent("tripleExprOrRef")
+            .forEach((tripleExprOrRefParent) => {
+                tripleExprOrRefParent
+                    .parent("EachOf", "expressions")
+                    .forEach((eachOfParent) => {
+                        recursivelyGatherTypesFromEachOfNodes(
+                            eachOfParent,
+                            rdfTypeSet
+                        );
+                    });
+                tripleExprOrRefParent
+                    .parent("Shape", "expression")
+                    .forEach((shapeParent) => {
+                        recursivelyGatherTypesFromShapeNodes(
+                            shapeParent,
+                            rdfTypeSet
+                        );
+                    });
+            });
+    });
+    const rdfTypes = rdfTypeSet.size > 0 ? Array.from(rdfTypeSet) : [undefined];
+    return rdfTypes;
+}

package/src/types.ts

@@ -0,0 +1,51 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+export interface ShapeType<T extends BaseType> {
+    schema: Schema;
+    shape: string;
+}
+
+export interface BaseType extends Record<string, any> {
+    "@id": string;
+}
+
+export type Schema = {
+    [id: string]: Shape;
+};
+
+export interface Shape {
+    iri: string;
+    predicates: Predicate[];
+}
+
+export type DataType = {
+    /** The required literal value(s), if type is `literal`. Others 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;
+    /** The type of object value for a triple constraint. */
+    valType: "number" | "string" | "boolean" | "iri" | "literal" | "shape";
+};
+
+export interface Predicate {
+    /** Allowed type of object. If more than one is present, either of them is allowed. */
+    dataTypes: DataType[];
+    /** The RDF predicate URI. */
+    iri: string;
+    /** The alias of the `predicateUri` when serialized to a JSON object. */
+    readablePredicate: string;
+    /** Maximum allowed number of values. `-1` means infinite. */
+    maxCardinality: number;
+    /** Minimum required number of values */
+    minCardinality: number;
+    /** If other (additional) values are permitted. Useful for literals. */
+    extra?: boolean;
+}

package/src/util/forAllShapes.ts

@@ -0,0 +1,39 @@
+// Copyright (c) 2023 Jackson Morgan
+// Licensed under the Apache License, Version 2.0
+// <LICENSE-APACHE2 or http://www.apache.org/licenses/LICENSE-2.0>
+// or the MIT license <LICENSE-MIT or http://opensource.org/licenses/MIT>,
+// at your option. All files in the project carrying such
+// notice may not be copied, modified, or distributed except
+// according to those terms.
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+import fs from "fs";
+import path from "node:path";
+
+export async function forAllShapes(
+    shapePath: string,
+    callback: (filename: string, shape: string) => Promise<void>
+): Promise<void> {
+    const shapeDir = await fs.promises.readdir(shapePath, {
+        withFileTypes: true,
+    });
+    // Filter out non-shex documents
+    const shexFiles = shapeDir.filter(
+        (file) => file.isFile() && file.name.endsWith(".shex")
+    );
+    const shexPromise = Promise.all(
+        shexFiles.map(async (file) => {
+            const fileName = path.parse(file.name).name;
+            // Get the content of each document
+            const shexC = await fs.promises.readFile(
+                path.join(shapePath, file.name),
+                "utf8"
+            );
+            await callback(fileName, shexC);
+        })
+    );
+
+    // Note: SHACL conversion omitted here.
+
+    await Promise.all([shexPromise]);
+}