ldkit 2.6.0 → 2.7.0

package/esm/cli.js

@@ -1,11 +1,14 @@
 #!/usr/bin/env node
 import { argv } from "node:process";
 import { styleText } from "node:util";
-import { readFileSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { Argument, Command } from "commander";
 import { contextToSchema } from "./scripts/context_to_schema.js";
 import { shexcToSchema, shexjToSchema } from "./scripts/shex_to_schema.js";
+import { shaclToSchema } from "./scripts/shacl_to_schema.js";
 import { schemaToScript } from "./scripts/schema_to_script.js";
+import { schemaToPackage } from "./scripts/schema_to_package.js";
 const asciiArt = String.raw `
   _     ____  _    _ _   
  | |   |  _ \| | _(_) |_ 
@@ -85,6 +88,56 @@ program.command("shexj-to-schema")
         console.error(styleText("red", `${error.message}`));
     }
 });
+program.command("shacl-to-schema")
+    .description("Convert a SHACL shapes graph from a file or URL to a LDkit schema")
+    .addArgument(new Argument("<method>", "type of input").choices([
+    "url",
+    "file",
+    "arg",
+]))
+    .argument("<input>", "input SHACL Turtle - file, URL, or string")
+    .option("--prefix-alias <mapping>", "rename a SHACL prefix in generated schema names (format: prefix=Alias). Repeatable.", (value, previous) => [...previous, value], [])
+    .action(async (method, input, opts) => {
+    try {
+        const resolvedInput = await resolve(method, input);
+        const prefixAliases = parsePrefixAliases(opts.prefixAlias);
+        const { schemas, extraNamespaces } = shaclToSchema(resolvedInput, {
+            prefixAliases,
+        });
+        console.log(schemaToScript(schemas, extraNamespaces));
+    }
+    catch (error) {
+        console.error(styleText("red", `${error.message}`));
+    }
+});
+program.command("shacl-to-package")
+    .description("Convert a SHACL shapes graph into a directory of per-namespace LDkit schema files (one .ts per prefix plus an index.ts barrel)")
+    .addArgument(new Argument("<method>", "type of input").choices([
+    "url",
+    "file",
+    "arg",
+]))
+    .argument("<input>", "input SHACL Turtle - file, URL, or string")
+    .argument("<outDir>", "output directory for the generated package")
+    .option("--prefix-alias <mapping>", "rename a SHACL prefix in generated schema names AND in the per-namespace file name (format: prefix=Alias). Repeatable.", (value, previous) => [...previous, value], [])
+    .action(async (method, input, outDir, opts) => {
+    try {
+        const resolvedInput = await resolve(method, input);
+        const prefixAliases = parsePrefixAliases(opts.prefixAlias);
+        const { schemas, extraNamespaces, schemaSourcePrefixes } = shaclToSchema(resolvedInput, { prefixAliases });
+        const { files } = schemaToPackage(schemas, extraNamespaces, {
+            prefixAliases,
+            schemaSourcePrefixes,
+        });
+        mkdirSync(outDir, { recursive: true });
+        for (const [base, contents] of files) {
+            writeFileSync(join(outDir, `${base}.ts`), contents);
+        }
+    }
+    catch (error) {
+        console.error(styleText("red", `${error.message}`));
+    }
+});
 // Check if no arguments were provided
 if (argv.length <= 2) {
     console.log(styleText("red", asciiArt));
@@ -93,6 +146,21 @@ if (argv.length <= 2) {
 else {
     program.parse(argv);
 }
+function parsePrefixAliases(pairs) {
+    if (!pairs || pairs.length === 0)
+        return {};
+    const result = {};
+    for (const pair of pairs) {
+        const eq = pair.indexOf("=");
+        if (eq <= 0 || eq === pair.length - 1) {
+            throw new Error(`Invalid --prefix-alias value "${pair}" (expected format: prefix=Alias)`);
+        }
+        const prefix = pair.substring(0, eq);
+        const alias = pair.substring(eq + 1);
+        result[prefix] = alias;
+    }
+    return result;
+}
 async function resolve(method, input) {
     if (method === "url") {
         try {

package/esm/library/options.d.ts

@@ -63,6 +63,10 @@ export declare function resolveOptions(options?: Options): {
     httpRetryDelayFallback?: number;
     httpRetryDelayLimit?: number;
     httpRetryStatusCodes?: number[];
+    httpRetryBodyCount?: number;
+    httpRetryBodyDelayFallback?: number;
+    httpRetryBodyAllowUnsafe?: boolean;
+    httpRetryBodyMaxBytes?: number;
     httpAbortSignal?: AbortSignal;
     httpCache?: boolean;
     fetch?: typeof fetch;

package/esm/library/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/library/options.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EAElB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEvD;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,OAAY;YAxCzC,YAAY;eACV,MAAM;UACV,MAAM;cACF,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CnC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAclE"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/library/options.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,YAAY,EAElB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;;GAQG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAU1B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAEvD;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,OAAY;YAxCzC,YAAY;eACV,MAAM;UACV,MAAM;cACF,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CnC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,YAAY,CAclE"}

package/esm/scripts/schema_to_package.d.ts

@@ -0,0 +1,10 @@
+import { type ExtraNamespace, type SchemaSpec } from "./schema_to_script.js";
+export type SchemaToPackageOptions = {
+    prefixAliases?: Record<string, string>;
+    schemaSourcePrefixes?: Map<string, string>;
+};
+export type SchemaPackage = {
+    files: Map<string, string>;
+};
+export declare function schemaToPackage(schemas: SchemaSpec[], extraNamespaces?: ExtraNamespace[], options?: SchemaToPackageOptions): SchemaPackage;
+//# sourceMappingURL=schema_to_package.d.ts.map

package/esm/scripts/schema_to_package.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema_to_package.d.ts","sourceRoot":"","sources":["../../src/scripts/schema_to_package.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,UAAU,EAEhB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvC,oBAAoB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC5B,CAAC;AAKF,wBAAgB,eAAe,CAC7B,OAAO,EAAE,UAAU,EAAE,EACrB,eAAe,GAAE,cAAc,EAAO,EACtC,OAAO,GAAE,sBAA2B,GACnC,aAAa,CAkDf"}

package/esm/scripts/schema_to_package.js

@@ -0,0 +1,109 @@
+import { schemaToScript, } from "./schema_to_script.js";
+const FALLBACK_FILE = "_unknown";
+const NAMESPACES_FILE = "namespaces";
+export function schemaToPackage(schemas, extraNamespaces = [], options = {}) {
+    const aliases = options.prefixAliases ?? {};
+    const sourcePrefixes = options.schemaSourcePrefixes ?? new Map();
+    const fileForPrefix = (prefix) => {
+        if (!prefix)
+            return FALLBACK_FILE;
+        const aliased = aliases[prefix];
+        return (aliased ?? prefix).toLowerCase();
+    };
+    const groups = new Map();
+    const schemaLocations = new Map();
+    for (const schema of schemas) {
+        const file = fileForPrefix(sourcePrefixes.get(schema.name));
+        schemaLocations.set(schema.name, file);
+        let bucket = groups.get(file);
+        if (!bucket) {
+            bucket = [];
+            groups.set(file, bucket);
+        }
+        bucket.push(schema);
+    }
+    const extraNamespaceTermsOverride = collectGlobalNamespaceTerms(extraNamespaces, schemas);
+    const files = new Map();
+    for (const [file, fileSchemas] of [...groups.entries()].toSorted(([a], [b]) => a.localeCompare(b))) {
+        const scopedExtras = filterExtras(extraNamespaces, fileSchemas);
+        const contents = schemaToScript(fileSchemas, scopedExtras, {
+            schemaLocations,
+            currentFile: file,
+            extraNamespacesImportFrom: NAMESPACES_FILE,
+        });
+        files.set(file, contents);
+    }
+    if (extraNamespaces.length > 0) {
+        files.set(NAMESPACES_FILE, buildNamespacesFile(extraNamespaces, extraNamespaceTermsOverride));
+    }
+    files.set("index", buildIndex(files));
+    return { files };
+}
+function buildNamespacesFile(extras, termsByPrefix) {
+    const lines = [`import { createNamespace } from "ldkit";`, ""];
+    const sorted = [...extras].sort((a, b) => a.prefix.localeCompare(b.prefix));
+    for (const ns of sorted) {
+        const terms = [...(termsByPrefix.get(ns.prefix) ?? new Set())]
+            .toSorted();
+        lines.push(`export const ${ns.prefix} = createNamespace(`);
+        lines.push(`  {`);
+        lines.push(`    iri: ${JSON.stringify(ns.iri)},`);
+        lines.push(`    prefix: ${JSON.stringify(`${ns.prefix}:`)},`);
+        lines.push(`    terms: [`);
+        for (const term of terms) {
+            lines.push(`      ${JSON.stringify(term)},`);
+        }
+        lines.push(`    ],`);
+        lines.push(`  } as const,`);
+        lines.push(`);`);
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+function filterExtras(extras, schemas) {
+    if (extras.length === 0)
+        return [];
+    const usedIris = collectUsedIris(schemas);
+    return extras.filter((ns) => [...usedIris].some((iri) => iri.startsWith(ns.iri)));
+}
+function collectUsedIris(schemas) {
+    const used = new Set();
+    for (const schema of schemas) {
+        for (const t of schema.type)
+            used.add(t);
+        for (const prop of Object.values(schema.properties)) {
+            used.add(prop.id);
+            if (prop.type)
+                used.add(prop.type);
+            if (prop.schema) {
+                for (const iri of collectUsedIris([prop.schema]))
+                    used.add(iri);
+            }
+        }
+    }
+    return used;
+}
+function collectGlobalNamespaceTerms(extras, schemas) {
+    const sortedExtras = [...extras].sort((a, b) => b.iri.length - a.iri.length);
+    const result = new Map();
+    const allIris = collectUsedIris(schemas);
+    for (const iri of allIris) {
+        for (const ns of sortedExtras) {
+            if (iri.startsWith(ns.iri)) {
+                const term = iri.substring(ns.iri.length);
+                let bucket = result.get(ns.prefix);
+                if (!bucket) {
+                    bucket = new Set();
+                    result.set(ns.prefix, bucket);
+                }
+                bucket.add(term);
+                break;
+            }
+        }
+    }
+    return result;
+}
+function buildIndex(files) {
+    const names = [...files.keys()].filter((f) => f !== "index").toSorted();
+    return names.map((name) => `export * from "./${name}";`).join("\n") + "\n";
+}