@shaclmate/cli 4.0.17 → 4.0.19

package/dist/cli.js

@@ -1,26 +1,16 @@
 #!/usr/bin/env node
-import * as fs from "node:fs";
-import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
-import { RdfDirectory, RdfFileSystemEntry } from "@rdfx/fs";
-import { AstJsonGenerator, Compiler, ShapesGraph, TsGenerator, ZodGenerator, } from "@shaclmate/compiler";
+import fs from "node:fs";
+import { AstJsonGenerator, Cx2Generator, TsGenerator, ZodGenerator, } from "@shaclmate/compiler";
 import { command, option, restPositionals, run, string, subcommands, } from "cmd-ts";
 import { ExistingPath } from "cmd-ts/dist/cjs/batteries/fs.js";
-import { DataFactory, Parser, Store, Writer } from "n3";
-import { pino } from "pino";
-import { EitherAsync } from "purify-ts";
-import SHACLValidator from "rdf-validate-shacl";
-import { shaclShaclDataset } from "./shaclShaclDataset.js";
+import { generate } from "./commands/generate.js";
+import { merge } from "./commands/merge.js";
+import { validate } from "./commands/validate.js";
 const inputPaths = restPositionals({
     displayName: "inputPaths",
     description: "paths to RDF files or directories of 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",
@@ -28,84 +18,10 @@ const outputFilePath = option({
     short: "o",
     type: string,
 });
-function generate({ generator, inputFiles, outputFilePath, }) {
-    if (inputFiles.length === 0) {
-        throw new Error("must specify at least one input shapes graph file path");
-    }
-    const inputParser = new Parser();
-    const dataset = new Store();
-    const iriPrefixes = [];
-    for (const inputFile of inputFiles) {
-        dataset.addQuads(inputParser.parse(fs.readFileSync(inputFile.path).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 prefixMap = new PrefixMap(iriPrefixes, { factory: DataFactory });
-    {
-        const validationReport = new SHACLValidator(shaclShaclDataset, {}).validate(dataset);
-        if (!validationReport.conforms) {
-            process.stderr.write("input is not valid SHACL:\n");
-            const n3WriterPrefixes = {};
-            for (const prefixEntry of prefixMap.entries()) {
-                n3WriterPrefixes[prefixEntry[0]] = prefixEntry[1].value;
-            }
-            const n3Writer = new Writer({
-                format: "text/turtle",
-                prefixes: n3WriterPrefixes,
-            });
-            for (const quad of validationReport.dataset) {
-                n3Writer.addQuad(quad);
-            }
-            n3Writer.end((_error, result) => process.stderr.write(result));
-            return;
-        }
-    }
-    ShapesGraph.builder()
-        .parseDataset(dataset, { prefixMap })
-        .map((_) => _.build())
-        .chain((shapesGraph) => new Compiler({ generator }).compile(shapesGraph))
-        .ifLeft((error) => {
-        throw error;
-    })
-        .ifRight((output) => {
-        if (outputFilePath.length === 0) {
-            process.stdout.write(output);
-        }
-        else {
-            fs.writeFileSync(outputFilePath, output);
-        }
-    });
-}
-async function resolveInputPaths(inputPaths) {
-    return EitherAsync(async ({ liftEither }) => {
-        const inputFiles = [];
-        for (const inputPath of inputPaths) {
-            const fileSystemEntry = await liftEither(await RdfFileSystemEntry.fromPath(inputPath));
-            if (fileSystemEntry instanceof RdfDirectory) {
-                for await (const inputFile of fileSystemEntry.files({
-                    recursive: true,
-                })) {
-                    inputFiles.push(inputFile);
-                }
-            }
-            else {
-                inputFiles.push(fileSystemEntry);
-            }
-        }
-        return inputFiles;
-    });
-}
 run(subcommands({
     cmds: {
         generate: subcommands({
+            name: "generate",
             cmds: {
                 "ast-json": command({
                     name: "ast-json",
@@ -115,11 +31,35 @@ run(subcommands({
                         outputFilePath,
                     },
                     handler: async ({ inputPaths, outputFilePath }) => {
-                        generate({
+                        (await generate({
                             generator: new AstJsonGenerator(),
-                            inputFiles: (await resolveInputPaths(inputPaths)).unsafeCoerce(),
+                            inputPaths,
                             outputFilePath,
-                        });
+                        })).unsafeCoerce();
+                    },
+                }),
+                cx2: command({
+                    name: "cx2",
+                    description: "generate Cytoscape Exchange Format Specification (Version 2)",
+                    args: {
+                        inputPaths,
+                        outputFilePath,
+                        visualPropertiesJsonFilePath: option({
+                            description: "path to a file containing the visualProperties JSON object to include in the CX2 file",
+                            long: "visual-properties-json-file-path",
+                            type: ExistingPath,
+                        }),
+                    },
+                    handler: async ({ inputPaths, outputFilePath, visualPropertiesJsonFilePath, }) => {
+                        let visualProperties;
+                        if (visualPropertiesJsonFilePath) {
+                            visualProperties = JSON.parse((await fs.promises.readFile(visualPropertiesJsonFilePath)).toString("utf-8"));
+                        }
+                        (await generate({
+                            generator: new Cx2Generator({ visualProperties }),
+                            inputPaths,
+                            outputFilePath,
+                        })).unsafeCoerce();
                     },
                 }),
                 ts: command({
@@ -130,11 +70,11 @@ run(subcommands({
                         outputFilePath,
                     },
                     handler: async ({ inputPaths, outputFilePath }) => {
-                        generate({
+                        (await generate({
                             generator: new TsGenerator(),
-                            inputFiles: (await resolveInputPaths(inputPaths)).unsafeCoerce(),
+                            inputPaths,
                             outputFilePath,
-                        });
+                        })).unsafeCoerce();
                     },
                 }),
                 zod: command({
@@ -145,15 +85,50 @@ run(subcommands({
                         outputFilePath,
                     },
                     handler: async ({ inputPaths, outputFilePath }) => {
-                        generate({
+                        (await generate({
                             generator: new ZodGenerator(),
-                            inputFiles: (await resolveInputPaths(inputPaths)).unsafeCoerce(),
+                            inputPaths,
                             outputFilePath,
-                        });
+                        })).unsafeCoerce();
                     },
                 }),
             },
-            name: "generate",
+        }),
+        merge: command({
+            name: "merge",
+            description: "merge one or more RDF files",
+            args: {
+                inputPaths,
+                outputFilePath,
+            },
+            handler: async ({ inputPaths, outputFilePath }) => {
+                (await merge({
+                    inputPaths,
+                    outputFilePath,
+                })).unsafeCoerce();
+            },
+        }),
+        validate: command({
+            name: "validate",
+            description: "validate a data graph with a shapes graph",
+            args: {
+                dataGraphPaths: restPositionals({
+                    description: "path(s) to a file or directory of data graph files",
+                    type: ExistingPath,
+                }),
+                shapesGraphPath: option({
+                    description: "path to a file or directory of shapes graph files",
+                    short: "s",
+                    long: "--shapes-graph",
+                    type: ExistingPath,
+                }),
+            },
+            handler: async ({ dataGraphPaths, shapesGraphPath }) => {
+                (await validate({
+                    dataGraphPaths,
+                    shapesGraphPaths: [shapesGraphPath],
+                })).unsafeCoerce();
+            },
         }),
     },
     description: "shaclmate command line interface",

package/dist/commands/generate.d.ts

@@ -0,0 +1,8 @@
+import type { Generator } from "@shaclmate/compiler";
+import { type Either } from "purify-ts";
+export declare function generate({ generator, inputPaths, outputFilePath, }: {
+    generator: Generator;
+    inputPaths: readonly string[];
+    outputFilePath: string;
+}): Promise<Either<Error, void>>;
+//# sourceMappingURL=generate.d.ts.map

package/dist/commands/generate.js

@@ -0,0 +1,36 @@
+import * as fs from "node:fs";
+import Serializer from "@rdfjs/serializer-turtle";
+import { Compiler, ShapesGraph } from "@shaclmate/compiler";
+import { EitherAsync } from "purify-ts";
+import SHACLValidator from "rdf-validate-shacl";
+import { parseInputs } from "./parseInputs.js";
+import { shaclShaclDataset } from "./shaclShaclDataset.js";
+export async function generate({ generator, inputPaths, outputFilePath, }) {
+    return EitherAsync(async ({ liftEither }) => {
+        if (inputPaths.length === 0) {
+            throw new Error("must specify at least one input shapes graph file path");
+        }
+        const { dataset, prefixMap } = await liftEither(await parseInputs(inputPaths));
+        {
+            const validationReport = await new SHACLValidator(shaclShaclDataset, {}).validate(dataset);
+            if (!validationReport.conforms) {
+                process.stderr.write("input is not valid SHACL:\n");
+                process.stderr.write(new Serializer({
+                    prefixes: prefixMap,
+                }).transform(validationReport.dataset));
+                return;
+            }
+        }
+        const output = await liftEither(ShapesGraph.builder()
+            .parseDataset(dataset, { prefixMap })
+            .map((_) => _.build())
+            .chain((shapesGraph) => new Compiler({ generator }).compile(shapesGraph)));
+        if (outputFilePath.length === 0) {
+            process.stdout.write(output);
+        }
+        else {
+            await fs.promises.writeFile(outputFilePath, output);
+        }
+    });
+}
+//# sourceMappingURL=generate.js.map

package/dist/commands/merge.d.ts

@@ -0,0 +1,6 @@
+import { type Either } from "purify-ts";
+export declare function merge({ inputPaths, outputFilePath, }: {
+    inputPaths: readonly string[];
+    outputFilePath: string;
+}): Promise<Either<Error, void>>;
+//# sourceMappingURL=merge.d.ts.map

package/dist/commands/merge.js

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import Serializer from "@rdfjs/serializer-turtle";
+import { EitherAsync } from "purify-ts";
+import { parseInputs } from "./parseInputs.js";
+export async function merge({ inputPaths, outputFilePath, }) {
+    return EitherAsync(async ({ liftEither }) => {
+        const { dataset, prefixMap } = await liftEither(await parseInputs(inputPaths));
+        const output = new Serializer({ prefixes: prefixMap }).transform(dataset);
+        if (outputFilePath.length === 0) {
+            process.stdout.write(output);
+        }
+        else {
+            await fs.promises.writeFile(outputFilePath, output);
+        }
+    });
+}
+//# sourceMappingURL=merge.js.map

package/dist/commands/parseInputs.d.ts

@@ -0,0 +1,8 @@
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import type { DatasetCore } from "@rdfjs/types";
+import { Either } from "purify-ts";
+export declare function parseInputs(inputPaths: readonly string[]): Promise<Either<Error, {
+    dataset: DatasetCore;
+    prefixMap: PrefixMap;
+}>>;
+//# sourceMappingURL=parseInputs.d.ts.map

package/dist/commands/parseInputs.js

@@ -0,0 +1,49 @@
+import DataFactory from "@rdfjs/data-model";
+import DatasetFactory from "@rdfjs/dataset";
+import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
+import { RdfDirectory, RdfFileSystemEntry } from "@rdfx/fs";
+import { Either, EitherAsync, Left } from "purify-ts";
+import { logger } from "../logger.js";
+export async function parseInputs(inputPaths) {
+    return EitherAsync(async ({ liftEither }) => {
+        const dataset = DatasetFactory.dataset();
+        const prefixMapInit = [];
+        for (const inputPath of inputPaths) {
+            const parseInputFileSystemEntry = async (inputFileSystemEntry) => {
+                if (inputFileSystemEntry instanceof RdfDirectory) {
+                    for await (const file of inputFileSystemEntry.files({
+                        recursive: true,
+                    })) {
+                        await parseInputFileSystemEntry(file);
+                    }
+                    return;
+                }
+                const inputFile = inputFileSystemEntry;
+                await liftEither(await new Promise((resolve) => {
+                    const inputQuadStream = inputFile.parse();
+                    inputQuadStream.on("data", (quad) => dataset.add(quad));
+                    inputQuadStream.on("end", () => resolve(Either.of(null)));
+                    inputQuadStream.on("error", (error) => resolve(Left(error)));
+                    inputQuadStream.on("prefix", (prefix, prefixNode) => {
+                        const existingPrefixMapEntry = prefixMapInit.find((prefixMapEntry) => prefixMapEntry[0] === prefix ||
+                            prefixMapEntry[1].equals(prefixNode));
+                        if (existingPrefixMapEntry) {
+                            if (existingPrefixMapEntry[0] !== prefix ||
+                                !existingPrefixMapEntry[1].equals(prefixNode)) {
+                                logger.warn("conflicting prefix %s: %s", prefix, prefixNode.value);
+                            }
+                            return;
+                        }
+                        prefixMapInit.push([prefix, prefixNode]);
+                    });
+                }));
+            };
+            await parseInputFileSystemEntry(await liftEither(await RdfFileSystemEntry.fromPath(inputPath)));
+        }
+        return {
+            dataset,
+            prefixMap: new PrefixMap(prefixMapInit, { factory: DataFactory }),
+        };
+    });
+}
+//# sourceMappingURL=parseInputs.js.map

package/dist/commands/validate.d.ts

@@ -0,0 +1,6 @@
+import { type Either } from "purify-ts";
+export declare function validate({ dataGraphPaths, shapesGraphPaths, }: {
+    dataGraphPaths: readonly string[];
+    shapesGraphPaths: readonly string[];
+}): Promise<Either<Error, void>>;
+//# sourceMappingURL=validate.d.ts.map

package/dist/commands/validate.js

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import Serializer from "@rdfjs/serializer-turtle";
+import { EitherAsync } from "purify-ts";
+import SHACLValidator from "rdf-validate-shacl";
+import * as tmp from "tmp-promise";
+import which from "which";
+import { logger } from "../logger.js";
+import { parseInputs } from "./parseInputs.js";
+function execFileStreaming(cmd, args) {
+    return new Promise((resolve) => {
+        const child = spawn(cmd, args, { stdio: "inherit" });
+        child.on("close", (code) => {
+            resolve(code);
+        });
+    });
+}
+export async function validate({ dataGraphPaths, shapesGraphPaths, }) {
+    return EitherAsync(async ({ liftEither }) => {
+        const { dataset: dataGraphDataset, prefixMap: dataGraphPrefixMap } = await liftEither(await parseInputs(dataGraphPaths));
+        if (dataGraphDataset.size === 0) {
+            throw new Error("data graph is empty!");
+        }
+        logger.info("data graph size: %d", dataGraphDataset.size);
+        const { dataset: shapesGraphDataset } = await liftEither(await parseInputs(shapesGraphPaths));
+        if (shapesGraphDataset.size === 0) {
+            throw new Error("shapes graph is empty!");
+        }
+        logger.info("shapes graph size: %d", shapesGraphDataset.size);
+        const serializer = new Serializer({
+            prefixes: dataGraphPrefixMap,
+        });
+        logger.info("validating with rdf-shacl-validate");
+        const validationReport = await new SHACLValidator(shapesGraphDataset, {}).validate(dataGraphDataset);
+        if (validationReport.conforms) {
+            logger.info("validated with rdf-shacl-validate: conforms");
+        }
+        else {
+            logger.info("validated with rdf-shacl-validate: does not conform");
+            process.stderr.write(serializer.transform(validationReport.dataset));
+            return;
+        }
+        const jenaShaclFilePath = await which("shacl", { nothrow: true });
+        const pyshaclFilePath = await which("pyshacl", { nothrow: true });
+        if (jenaShaclFilePath === null && pyshaclFilePath === null) {
+            logger.debug("neither Jena nor pyshacl found on PATH");
+            return;
+        }
+        await tmp.withDir(async ({ path: tmpDirectoryPath }) => {
+            const dataGraphFilePath = path.join(tmpDirectoryPath, "data.ttl");
+            logger.debug("writing data graph to %s", dataGraphFilePath);
+            await fs.writeFile(dataGraphFilePath, serializer.transform(dataGraphDataset));
+            logger.debug("wrote data graph to %s", dataGraphFilePath);
+            const shapesGraphFilePath = path.join(tmpDirectoryPath, "shapes.ttl");
+            logger.debug("writing shapes graph to %s", shapesGraphFilePath);
+            await fs.writeFile(shapesGraphFilePath, serializer.transform(shapesGraphDataset));
+            logger.debug("wrote shapes graph to %s", shapesGraphFilePath);
+            if (jenaShaclFilePath !== null) {
+                const args = [
+                    "validate",
+                    "--data",
+                    dataGraphFilePath,
+                    "--shapes",
+                    shapesGraphFilePath,
+                ];
+                logger.info("validating with Jena (args=%s)", args);
+                const code = await execFileStreaming(jenaShaclFilePath, args);
+                logger.info("validated with Jena: %s", code === 0 ? "conforms" : "does not conform");
+                if (code !== 0) {
+                    return;
+                }
+            }
+            else {
+                logger.info("Jena not found on PATH, skipping");
+            }
+            if (pyshaclFilePath !== null) {
+                const args = ["-s", shapesGraphFilePath, dataGraphFilePath];
+                logger.info("validating with pyshacl (args=%s)", args);
+                const code = await execFileStreaming(pyshaclFilePath, args);
+                logger.info("validated with pyshacl: %s", code === 0 ? "conforms" : "does not conform");
+                if (code !== 0) {
+                    return;
+                }
+            }
+            else {
+                logger.info("pyshacl not found on PATH, skipping");
+            }
+        }, {
+            unsafeCleanup: true,
+        });
+    });
+}
+//# sourceMappingURL=validate.js.map

package/dist/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("pino").Logger<never>;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.js

@@ -0,0 +1,14 @@
+import { pino } from "pino";
+export const logger = pino({
+    level: process.env["NODE_ENV"] === "development" ||
+        process.env["NODE_ENV"] === "test"
+        ? "debug"
+        : "info",
+    transport: {
+        target: "pino-pretty",
+        options: {
+            colorize: true,
+        },
+    },
+}, pino["destination"] ? pino.destination(2) : undefined);
+//# sourceMappingURL=logger.js.map

package/package.json

@@ -3,24 +3,34 @@
     "shaclmate": "dist/cli.js"
   },
   "dependencies": {
-    "@shaclmate/compiler": "4.0.17",
+    "@shaclmate/compiler": "4.0.19",
+    "@rdfjs/data-model": "~2.1.1",
+    "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
-    "@rdfjs/types": "~2.0.1",
+    "@rdfjs/serializer-turtle": "~1.1.5",
     "@rdfx/fs": "0.0.7",
-    "@types/n3": "~1.26.0",
-    "@types/rdfjs__prefix-map": "~0.1.5",
-    "cmd-ts": "~0.13.0",
-    "n3": "~1.26.0",
+    "cmd-ts": "~0.15.0",
     "pino": "~9.1.0",
+    "pino-pretty": "~13.1.2",
     "purify-ts": "~2.1.4",
-    "rdf-validate-shacl": "0.5.8"
+    "rdf-validate-shacl": "0.6.5",
+    "tmp-promise": "~3.0.3",
+    "which": "~6.0.1"
   },
   "description": "Command line program to generate TypeScript code from SHACL shapes",
-  "devDependencies": {},
+  "devDependencies": {
+    "@rdfjs/types": "~2.0.1",
+    "@types/rdfjs__data-model": "~2.0.9",
+    "@types/rdfjs__dataset": "~2.0.7",
+    "@types/rdfjs__prefix-map": "~0.1.5",
+    "@types/which": "~3.0.4"
+  },
   "files": [
     "README.md",
     "dist/*.d.ts",
-    "dist/*.js"
+    "dist/*.js",
+    "dist/commands/*.d.ts",
+    "dist/commands/*.js"
   ],
   "homepage": "https://github.com/minorg/shaclmate",
   "keywords": [
@@ -46,5 +56,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.17"
+  "version": "4.0.19"
 }