@ng-org/shex-orm 0.1.2-alpha.1

package/dist/cli.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { build } from "./build.js";
+program
+    .name("NG-ORM")
+    .description("CLI to some JavaScript string utilities")
+    .version("0.1.0");
+program
+    .command("build")
+    .description("Build contents of a shex folder into Shape Types")
+    .option("-i, --input <inputPath>", "Provide the input path", "./.shapes")
+    .option("-o, --output <outputPath>", "Provide the output path", "./.orm")
+    .option("-b, --baseIRI <baseIri>", "The base IRI for anonymous shapes", "https://nextgraph.org/shapes#")
+    .action(build);
+program.parse();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./types.js";

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

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

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

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

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

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import annotateReadablePredicates from "../util/annotateReadablePredicates.js";
+import { shexJConverter } from "../converter.js";
+const TYPE_IRI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+function buildSchema() {
+    return {
+        type: "Schema",
+        shapes: [
+            {
+                type: "ShapeDecl",
+                id: "http://example.org/Expense",
+                shapeExpr: {
+                    type: "Shape",
+                    expression: {
+                        type: "EachOf",
+                        expressions: [
+                            {
+                                type: "TripleConstraint",
+                                predicate: TYPE_IRI,
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    values: [
+                                        {
+                                            value: "http://example.org/Expense",
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+            {
+                type: "ShapeDecl",
+                id: "http://example.org/ExpenseCategory",
+                shapeExpr: {
+                    type: "Shape",
+                    extra: [TYPE_IRI],
+                    expression: {
+                        type: "EachOf",
+                        expressions: [
+                            {
+                                type: "TripleConstraint",
+                                predicate: TYPE_IRI,
+                                valueExpr: {
+                                    type: "NodeConstraint",
+                                    values: [
+                                        {
+                                            value: "http://example.org/ExpenseCategory",
+                                        },
+                                    ],
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        ],
+    };
+}
+async function buildTypingsText() {
+    const schema = buildSchema();
+    annotateReadablePredicates(schema);
+    const [typings] = await shexJConverter(schema);
+    return typings.typingsString;
+}
+describe("ShexJTypingTransformer", () => {
+    it("emits literal unions for rdf:type constraints", async () => {
+        const typings = await buildTypingsText();
+        expect(typings).toMatch(/interface Expense[\s\S]*?"@type": "http:\/\/example\.org\/Expense";/);
+    });
+    it("treats EXTRA rdf:type predicates as plural", async () => {
+        const typings = await buildTypingsText();
+        expect(typings).toMatch(/interface ExpenseCategory[\s\S]*?"@type": Set<"http:\/\/example\.org\/ExpenseCategory" \|[\s]*\(?string[\s]*&[\s]*\{[\s]*\}\)?>;/);
+    });
+});

package/dist/schema-converter/converter.d.ts

@@ -0,0 +1,12 @@
+import type { Schema } from "@ldo/traverser-shexj";
+import * as dom from "dts-dom";
+import type { Schema as ShapeSchema } from "../types.ts";
+export interface TypingReturn {
+    typingsString: string;
+    typings: {
+        typingString: string;
+        dts: dom.TopLevelDeclaration;
+    }[];
+}
+export declare function shexJConverter(shexj: Schema): Promise<[TypingReturn, ShapeSchema]>;
+//# sourceMappingURL=converter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../src/schema-converter/converter.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,GAAG,MAAM,SAAS,CAAC;AAM/B,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAS,MAAM,aAAa,CAAC;AAEhE,MAAM,WAAW,YAAY;IACzB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE;QACL,YAAY,EAAE,MAAM,CAAC;QACrB,GAAG,EAAE,GAAG,CAAC,mBAAmB,CAAC;KAChC,EAAE,CAAC;CACP;AAED,wBAAsB,cAAc,CAChC,KAAK,EAAE,MAAM,GACd,OAAO,CAAC,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC,CAkDtC"}

package/dist/schema-converter/converter.js

@@ -0,0 +1,79 @@
+// Copyright (c) 2025 Laurin Weger, Par le Peuple, NextGraph.org developers
+// All rights reserved.
+// 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 { jsonld2graphobject } from "jsonld2graphobject";
+import * as dom from "dts-dom";
+import { ShexJTypingTransformerCompact, additionalCompactEnumAliases, } from "./transformers/ShexJTypingTransformer.js";
+import { ShexJSchemaTransformerCompact } from "./transformers/ShexJSchemaTransformer.js";
+export async function shexJConverter(shexj) {
+    // Prepare processed schema (names still rely on context visitor)
+    const processedShexj = (await jsonld2graphobject({
+        ...shexj,
+        "@id": "SCHEMA",
+        "@context": "http://www.w3.org/ns/shex.jsonld",
+    }, "SCHEMA"));
+    additionalCompactEnumAliases.clear();
+    const declarations = await ShexJTypingTransformerCompact.transform(processedShexj, "Schema", null);
+    const compactSchemaShapesUnflattened = await ShexJSchemaTransformerCompact.transform(processedShexj, "Schema", null);
+    const compactSchema = flattenSchema(compactSchemaShapesUnflattened);
+    // Append only enum aliases (no interface Id aliases in compact format now)
+    const hasName = (d) => typeof d.name === "string";
+    additionalCompactEnumAliases.forEach((alias) => {
+        const exists = declarations.some((d) => hasName(d) && d.name === alias);
+        if (!exists)
+            declarations.push(dom.create.alias(alias, dom.create.namedTypeReference("IRI")));
+    });
+    const typings = declarations.map((declaration) => ({
+        typingString: dom
+            .emit(declaration, {
+            rootFlags: dom.ContextFlags.InAmbientNamespace,
+        })
+            .replace(/\r\n/g, "\n"),
+        dts: declaration,
+    }));
+    const header = `export type IRI = string;\n\n`;
+    const typingsString = header + typings.map((t) => `export ${t.typingString}`).join("");
+    return [{ typingsString, typings }, compactSchema];
+}
+/** Shapes may be nested. Put all to their root and give nested ones ids. */
+function flattenSchema(shapes) {
+    let schema = {};
+    for (const shape of shapes) {
+        schema[shape.iri] = shape;
+        // Find nested, unflattened (i.e. anonymous) schemas in predicates' dataTypes.
+        for (const pred of shape.predicates) {
+            for (let i = 0; i < pred.dataTypes.length; i++) {
+                const dt = pred.dataTypes[i];
+                if (dt.valType === "shape" &&
+                    typeof dt.shape === "object" &&
+                    dt.shape !== null) {
+                    // create a deterministic id for the nested shape; include index if multiple shape entries exist
+                    const shapeCount = pred.dataTypes.filter((d) => d.valType === "shape").length;
+                    const newId = shape.iri +
+                        "||" +
+                        pred.iri +
+                        (shapeCount > 1 ? `||${i}` : "");
+                    // Recurse
+                    const flattened = flattenSchema([
+                        {
+                            ...dt.shape,
+                            iri: newId,
+                        },
+                    ]);
+                    // Replace the nested schema with its new id.
+                    dt.shape = newId;
+                    schema = { ...schema, ...flattened };
+                }
+            }
+        }
+        // Flatten / Recurse
+    }
+    return schema;
+}

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

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

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

@@ -0,0 +1,14 @@
+import type { ShapeType } from "@ng-org/shex-orm";
+import { <%- fileName %>Schema } from "./<%- fileName %>.schema";
+    import type {
+    <% typings.forEach((typing)=> { if (!/Id$/.test(typing.dts.name)) { -%>
+      <%- typing.dts.name %>,
+        <% } }); -%>} from "./<%- fileName %>.typings";
+
+            // 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 %>",
+                        };
+                        <% } }); -%>

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

@@ -0,0 +1,14 @@
+export type IRI = string;
+
+/**
+* =============================================================================
+* Typescript Typings for <%- fileName %>
+  * =============================================================================
+  */
+
+  <% typings.forEach((typing)=> { -%>
+    /**
+    * <%- typing.dts.name %> Type
+      */
+      export <%- typing.typingString -%>
+        <% }); -%>

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

@@ -0,0 +1,348 @@
+import type { Predicate, DataType, Shape } from "../../types.ts";
+export declare const ShexJSchemaTransformerCompact: import("@ldo/type-traverser").Transformer<{
+    Schema: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Schema;
+        properties: {
+            startActs: "SemAct";
+            start: "shapeExprOrRef";
+            imports: "IRIREF";
+            shapes: "ShapeDecl";
+        };
+    };
+    ShapeDecl: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeDecl;
+        properties: {
+            id: "shapeDeclLabel";
+            abstract: "BOOL";
+            restricts: "shapeExprOrRef";
+            shapeExpr: "shapeExpr";
+        };
+    };
+    shapeExpr: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeExpr;
+        typeNames: "ShapeOr" | "ShapeAnd" | "ShapeNot" | "NodeConstraint" | "Shape" | "ShapeExternal";
+    };
+    shapeExprOrRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeExprOrRef;
+        typeNames: "shapeExpr" | "shapeDeclRef";
+    };
+    ShapeOr: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeOr;
+        properties: {
+            shapeExprs: "shapeExprOrRef";
+        };
+    };
+    ShapeAnd: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeAnd;
+        properties: {
+            shapeExprs: "shapeExprOrRef";
+        };
+    };
+    ShapeNot: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeNot;
+        properties: {
+            shapeExpr: "shapeExprOrRef";
+        };
+    };
+    ShapeExternal: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ShapeExternal;
+        properties: Record<string, never>;
+    };
+    shapeDeclRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeDeclRef;
+        typeNames: "shapeDeclLabel" | "ShapeDecl";
+    };
+    shapeDeclLabel: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").shapeDeclLabel;
+        typeNames: "IRIREF" | "BNODE";
+    };
+    NodeConstraint: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").NodeConstraint;
+        properties: {
+            datatype: "IRIREF";
+            values: "valueSetValue";
+            length: "INTEGER";
+            minlength: "INTEGER";
+            maxlength: "INTEGER";
+            pattern: "STRING";
+            flags: "STRING";
+            mininclusive: "numericLiteral";
+            minexclusive: "numericLiteral";
+            totaldigits: "INTEGER";
+            fractiondigits: "INTEGER";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    numericLiteral: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").numericLiteral;
+        typeNames: "INTEGER" | "DECIMAL" | "DOUBLE";
+    };
+    valueSetValue: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").valueSetValue;
+        typeNames: "objectValue" | "IriStem" | "IriStemRange" | "LiteralStem" | "LiteralStemRange" | "Language" | "LanguageStem" | "LanguageStemRange";
+    };
+    objectValue: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").objectValue;
+        typeNames: "IRIREF" | "ObjectLiteral";
+    };
+    ObjectLiteral: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").ObjectLiteral;
+        properties: {
+            value: "STRING";
+            language: "STRING";
+            type: "STRING";
+        };
+    };
+    IriStem: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").IriStem;
+        properties: {
+            stem: "IRIREF";
+        };
+    };
+    IriStemRange: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").IriStemRange;
+        properties: {
+            stem: "IRIREF";
+            exclusions: "IriStemRangeExclusions";
+        };
+    };
+    IriStemRangeExclusions: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").IRIREF | import("@ldo/traverser-shexj").IriStem;
+        typeNames: "IRIREF" | "IriStem";
+    };
+    LiteralStem: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LiteralStem;
+        properties: {
+            stem: "STRING";
+        };
+    };
+    LiteralStemRange: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LiteralStemRange;
+        properties: {
+            stem: "LiteralStemRangeStem";
+            exclusions: "LiteralStemRangeExclusions";
+        };
+    };
+    LiteralStemRangeStem: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").STRING | import("@ldo/traverser-shexj").Wildcard;
+        typeNames: "STRING" | "Wildcard";
+    };
+    LiteralStemRangeExclusions: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").STRING | import("@ldo/traverser-shexj").LiteralStem;
+        typeNames: "STRING" | "LiteralStem";
+    };
+    Language: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Language;
+        properties: {
+            languageTag: "LANGTAG";
+        };
+    };
+    LanguageStem: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LanguageStem;
+        properties: {
+            stem: "LANGTAG";
+        };
+    };
+    LanguageStemRange: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").LanguageStemRange;
+        properties: {
+            stem: "LanguageStemRangeStem";
+            exclusions: "LanguageStemRangeExclusions";
+        };
+    };
+    LanguageStemRangeStem: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").LANGTAG | import("@ldo/traverser-shexj").Wildcard;
+        typeNames: "LANGTAG" | "Wildcard";
+    };
+    LanguageStemRangeExclusions: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").LANGTAG | import("@ldo/traverser-shexj").LanguageStem;
+        typeNames: "LANGTAG" | "LanguageStem";
+    };
+    Wildcard: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Wildcard;
+        properties: Record<string, never>;
+    };
+    Shape: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Shape;
+        properties: {
+            closed: "BOOL";
+            extra: "IRIREF";
+            extends: "shapeExprOrRef";
+            expression: "tripleExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    tripleExpr: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExpr;
+        typeNames: "EachOf" | "OneOf" | "TripleConstraint";
+    };
+    tripleExprOrRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExprOrRef;
+        typeNames: "tripleExpr" | "tripleExprRef";
+    };
+    EachOf: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").EachOf;
+        properties: {
+            id: "tripleExprLabel";
+            min: "INTEGER";
+            max: "INTEGER";
+            expressions: "tripleExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    OneOf: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").OneOf;
+        properties: {
+            id: "tripleExprLabel";
+            min: "INTEGER";
+            max: "INTEGER";
+            expressions: "tripleExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    TripleConstraint: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").TripleConstraint;
+        properties: {
+            id: "tripleExprLabel";
+            min: "INTEGER";
+            max: "INTEGER";
+            inverse: "BOOL";
+            predicate: "IRIREF";
+            valueExpr: "shapeExprOrRef";
+            semActs: "SemAct";
+            annotations: "Annotation";
+        };
+    };
+    tripleExprRef: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExprRef;
+        typeNames: "tripleExprLabel";
+    };
+    tripleExprLabel: {
+        kind: "union";
+        type: import("@ldo/traverser-shexj").tripleExprLabel;
+        typeNames: "IRIREF" | "BNODE";
+    };
+    SemAct: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").SemAct;
+        properties: {
+            name: "IRIREF";
+            code: "STRING";
+        };
+    };
+    Annotation: {
+        kind: "interface";
+        type: import("@ldo/traverser-shexj").Annotation;
+        properties: {
+            predicate: "IRI";
+            object: "objectValue";
+        };
+    };
+    IRIREF: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").IRIREF;
+    };
+    BNODE: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").BNODE;
+    };
+    INTEGER: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").INTEGER;
+    };
+    STRING: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").STRING;
+    };
+    DECIMAL: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").DECIMAL;
+    };
+    DOUBLE: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").DOUBLE;
+    };
+    LANGTAG: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").LANGTAG;
+    };
+    BOOL: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").BOOL;
+    };
+    IRI: {
+        kind: "primitive";
+        type: import("@ldo/traverser-shexj").IRI;
+    };
+}, {
+    Schema: {
+        return: Shape[];
+    };
+    ShapeDecl: {
+        return: Shape;
+    };
+    Shape: {
+        return: Shape;
+    };
+    EachOf: {
+        return: Shape;
+    };
+    TripleConstraint: {
+        return: Predicate;
+    };
+    NodeConstraint: {
+        return: DataType;
+    };
+    ShapeOr: {
+        return: DataType[];
+    };
+    ShapeAnd: {
+        return: never;
+    };
+    ShapeNot: {
+        return: never;
+    };
+    ShapeExternal: {
+        return: never;
+    };
+}, null>;
+//# sourceMappingURL=ShexJSchemaTransformer.d.ts.map

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

@@ -0,0 +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;AA0DjE,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,CAAA;KAAE;aAC3B;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;QA2MtC,CAAC"}