@shaclmate/cli 2.0.12

package/cli.d.ts

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

package/cli.js

@@ -0,0 +1,151 @@
+import * as fs from "node:fs";
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap";
+import { ShapesGraphToAstTransformer } from "@shaclmate/compiler/ShapesGraphToAstTransformer.js";
+import * as generators from "@shaclmate/compiler/generators";
+import { dashDataset } from "@shaclmate/compiler/vocabularies/dashDataset.js";
+import { array, command, multioption, oneOf, option, restPositionals, run, string, subcommands, } from "cmd-ts";
+import { ExistingPath } from "cmd-ts/dist/esm/batteries/fs.js";
+import { DataFactory, Parser, Store } from "n3";
+import pino from "pino";
+import { ShapesGraph } from "shacl-ast";
+const inputFilePaths = restPositionals({
+    displayName: "inputFilePaths",
+    description: "paths to RDF files containing SHACL shapes",
+    type: ExistingPath,
+});
+const logger = pino({
+    level: process.env["NODE_ENV"] === "development" ||
+        process.env["NODE_ENV"] === "test"
+        ? "debug"
+        : "info",
+}, pino["destination"] ? pino.destination(2) : undefined);
+const outputFilePath = option({
+    defaultValue: () => "",
+    description: "path to a file to write output to; if not specified, write to stdout",
+    long: "output-path",
+    short: "o",
+    type: string,
+});
+function readInput(inputFilePaths) {
+    if (inputFilePaths.length === 0) {
+        throw new Error("must specify at least one input shapes graph file path");
+    }
+    const inputParser = new Parser();
+    const dataset = new Store();
+    for (const quad of dashDataset) {
+        dataset.add(quad);
+    }
+    const iriPrefixes = [];
+    for (const inputFilePath of inputFilePaths) {
+        dataset.addQuads(inputParser.parse(fs.readFileSync(inputFilePath).toString(), null, (prefix, prefixNode) => {
+            const existingIriPrefix = iriPrefixes.find((iriPrefix) => iriPrefix[0] === prefix || iriPrefix[1].equals(prefixNode));
+            if (existingIriPrefix) {
+                if (existingIriPrefix[0] !== prefix ||
+                    !existingIriPrefix[1].equals(prefixNode)) {
+                    logger.warn("conflicting prefix %s: %s", prefix, prefixNode.value);
+                }
+                return;
+            }
+            iriPrefixes.push([prefix, prefixNode]);
+        }));
+    }
+    const shapesGraph = ShapesGraph.fromDataset(dataset);
+    return new ShapesGraphToAstTransformer({
+        iriPrefixMap: new PrefixMap(iriPrefixes, { factory: DataFactory }),
+        shapesGraph,
+    })
+        .transform()
+        .ifLeft((error) => {
+        throw error;
+    })
+        .extract();
+}
+function writeOutput(output, outputFilePath) {
+    if (outputFilePath.length === 0) {
+        process.stdout.write(output);
+    }
+    else {
+        fs.writeFileSync(outputFilePath, output);
+    }
+}
+run(subcommands({
+    cmds: {
+        generate: command({
+            name: "generate",
+            description: "generate TypeScript for the SHACL Shapes Graph AST",
+            args: {
+                dataFactoryImport: option({
+                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
+                        .dataFactoryImport,
+                    description: "import line to get an RDF/JS DataFactory",
+                    long: "data-factory-import",
+                    type: string,
+                }),
+                dataFactoryVariable: option({
+                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
+                        .dataFactoryVariable,
+                    description: "variable of the RDF/JS DataFactory that was imported",
+                    long: "data-factory-variable",
+                    type: string,
+                }),
+                features: multioption({
+                    description: "generator features to enable",
+                    long: "feature",
+                    type: array(oneOf([
+                        "class",
+                        "equals",
+                        "fromRdf",
+                        "toRdf",
+                        "sparql-graph-patterns",
+                    ])),
+                }),
+                inputFilePaths,
+                outputFilePath,
+                objectTypeDeclarationType: option({
+                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
+                        .objectTypeDeclarationType,
+                    long: "object-type-declaration-type",
+                    type: oneOf(["class", "interface"]),
+                }),
+                objectTypeDiscriminatorPropertyName: option({
+                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
+                        .objectTypeDiscriminatorPropertyName,
+                    description: "name of a property to add to generated object types to discriminate them with a string enum",
+                    long: "object-type-discriminator-property-name",
+                    type: string,
+                }),
+                objectTypeIdentifierPropertyName: option({
+                    defaultValue: () => generators.ts.TsGenerator.Configuration.Defaults
+                        .objectTypeIdentifierPropertyName,
+                    description: "name of a property to add to generated object types to discriminate them with a string enum",
+                    long: "object-type-discriminator-property-name",
+                    type: string,
+                }),
+            },
+            handler: async ({ dataFactoryImport, dataFactoryVariable, features, inputFilePaths, objectTypeDeclarationType, objectTypeDiscriminatorPropertyName, objectTypeIdentifierPropertyName, outputFilePath, }) => {
+                writeOutput(new generators.ts.TsGenerator(readInput(inputFilePaths), new generators.ts.TsGenerator.Configuration({
+                    dataFactoryImport,
+                    dataFactoryVariable,
+                    features: new Set(features),
+                    objectTypeDeclarationType: objectTypeDeclarationType,
+                    objectTypeDiscriminatorPropertyName,
+                    objectTypeIdentifierPropertyName,
+                })).generate(), outputFilePath);
+            },
+        }),
+        "show-ast-json": command({
+            name: "show-ast-json",
+            description: "show AST JSON for the SHACL Shapes Graph AST",
+            args: {
+                inputFilePaths,
+                outputFilePath,
+            },
+            handler: async ({ inputFilePaths, outputFilePath }) => {
+                writeOutput(new generators.json.AstJsonGenerator(readInput(inputFilePaths)).generate(), outputFilePath);
+            },
+        }),
+    },
+    description: "shaclmate command line interface",
+    name: "shaclmate",
+}), process.argv.slice(2));
+//# sourceMappingURL=cli.js.map

package/package.json

@@ -0,0 +1,42 @@
+{
+  "bin": {
+    "shaclmate": "cli.js"
+  },
+  "dependencies": {
+    "@shaclmate/compiler": "2.0.12",
+    "cmd-ts": "^0.13.0",
+    "pino": "^9.1.0"
+  },
+  "devDependencies": {},
+  "files": ["*.d.ts", "*.js"],
+  "main": "index.js",
+  "license": "Apache-2.0",
+  "name": "@shaclmate/cli",
+  "scripts": {
+    "build": "tsc -b",
+    "check": "biome check",
+    "check:write": "biome check --write",
+    "check:write:unsafe": "biome check --write --unsafe",
+    "clean": "rimraf -g **/*.d.ts* **/*.js **/*.js.map tsconfig.tsbuildinfo",
+    "format": "biome format",
+    "format:write": "biome format --write",
+    "format:write:unsafe": "biome format --write --unsafe",
+    "rebuild": "run-s clean build",
+    "link-dependencies": "npm link purify-ts-helpers rdfjs-resource",
+    "lint": "biome lint",
+    "lint:write": "biome lint --write",
+    "lint:write:unsafe": "biome lint --write --unsafe",
+    "test": "biome check && vitest run",
+    "test:coverage": "biome check && vitest run --coverage",
+    "test:watch": "vitest watch",
+    "unlink": "npm unlink -g @shaclmate/cli",
+    "watch": "tsc -w --preserveWatchOutput"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/minorg/shaclmate"
+  },
+  "type": "module",
+  "types": "index.d.ts",
+  "version": "2.0.12"
+}