ldkit 2.2.0 → 2.4.0

package/esm/scripts/schema_to_script.js

@@ -0,0 +1,222 @@
+import { dbo, dc, dcterms, foaf, gr, ldkit, owl, rdf, rdfs, schema, sioc, skos, xsd, } from "../namespaces.js";
+const NAMESPACES = [
+    dbo,
+    dc,
+    dcterms,
+    foaf,
+    gr,
+    ldkit,
+    owl,
+    rdf,
+    rdfs,
+    schema,
+    sioc,
+    skos,
+    xsd,
+];
+export function schemaToScript(schemas) {
+    const printer = new SchemaPrinter();
+    return printer.print(schemas);
+}
+class SchemaPrinter {
+    constructor() {
+        Object.defineProperty(this, "usedNamespaces", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "space", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "  "
+        });
+    }
+    print(schemas) {
+        const orderedSchemas = this.orderSchemasByDependencies(schemas);
+        const printedSchemas = [];
+        for (const schema of orderedSchemas) {
+            this.extractNamespaces(schema);
+            const printedSchema = this.printSchema(schema);
+            printedSchemas.push(printedSchema);
+        }
+        if (this.usedNamespaces.size > 0) {
+            printedSchemas.unshift(this.printImports());
+        }
+        return printedSchemas.join("\n");
+    }
+    orderSchemasByDependencies(schemas) {
+        const orderedSchemas = [];
+        const processedSchemas = new Set();
+        const dependencies = schemas.map((schema) => {
+            return {
+                schemaName: schema.name,
+                dependencies: this.getSchemaDependencies(schema),
+            };
+        });
+        let unresolved = schemas.length;
+        while (unresolved > 0) {
+            let progress = false;
+            for (const info of dependencies) {
+                if (processedSchemas.has(info.schemaName)) {
+                    continue;
+                }
+                const allDepsProcessed = info.dependencies.every((dep) => processedSchemas.has(dep));
+                if (allDepsProcessed) {
+                    orderedSchemas.push(schemas.find((schema) => schema.name === info.schemaName));
+                    processedSchemas.add(info.schemaName);
+                    unresolved--;
+                    progress = true;
+                }
+            }
+            if (!progress) {
+                throw new Error("Circular dependency detected");
+            }
+        }
+        return orderedSchemas;
+    }
+    getSchemaDependencies(schema) {
+        const dependencies = [];
+        for (const property of Object.values(schema.properties)) {
+            if (property.schemaRef) {
+                dependencies.push(property.schemaRef);
+            }
+            if (property.schema) {
+                dependencies.push(...this.getSchemaDependencies(property.schema));
+            }
+        }
+        return dependencies;
+    }
+    extractNamespace(value) {
+        if (value === "@id") {
+            this.usedNamespaces.add(this.printPrefix(ldkit));
+            return;
+        }
+        for (const namespace of NAMESPACES) {
+            if (value.startsWith(namespace.$iri)) {
+                this.usedNamespaces.add(this.printPrefix(namespace));
+                return;
+            }
+        }
+    }
+    extractNamespaces(schema) {
+        for (const typeValue of schema.type) {
+            this.extractNamespace(typeValue);
+        }
+        for (const property of Object.values(schema.properties)) {
+            this.extractNamespace(property.id);
+            if (property.type) {
+                this.extractNamespace(property.type);
+            }
+            if (property.schema) {
+                this.extractNamespaces(property.schema);
+            }
+        }
+    }
+    printImports() {
+        const namespacesString = Array.from(this.usedNamespaces)
+            .toSorted()
+            .join(", ");
+        return `import { ${namespacesString} } from "ldkit/namespaces";\n`;
+    }
+    printSchema(schema) {
+        const type = this.printType(schema);
+        const properties = this.printProperties(schema);
+        return [
+            `export const ${schema.name} = {`,
+            this.indent(type),
+            this.indent(properties),
+            `} as const;\n`,
+        ].filter(Boolean).join("\n");
+    }
+    printSubSchema(schema) {
+        const type = this.printType(schema);
+        const properties = this.printProperties(schema);
+        return [
+            `"@schema": {`,
+            this.indent(type),
+            this.indent(properties),
+            `},`,
+        ].filter(Boolean).join("\n");
+    }
+    printProperties(schema) {
+        if (Object.keys(schema.properties).length === 0) {
+            return null;
+        }
+        return Object.entries(schema.properties)
+            .map(([key, prop]) => this.printProperty(key, prop))
+            .join("\n");
+    }
+    printProperty(key, prop) {
+        if (!prop.schema && !prop.schemaRef &&
+            !prop.optional && !prop.array &&
+            !prop.multilang && !prop.inverse &&
+            (!prop.type || prop.type === xsd.string)) {
+            return `${this.printKey(key)}: ${this.printPrefixed(prop.id)},`;
+        }
+        const builder = [
+            `${this.printKey(key)}: {`,
+            this.indent(`"@id": ${this.printPrefixed(prop.id)},`),
+        ];
+        if (prop.type) {
+            builder.push(this.indent(`"@type": ${this.printPrefixed(prop.type)},`));
+        }
+        if (prop.schema) {
+            const subSchema = this.printSubSchema(prop.schema);
+            builder.push(this.indent(subSchema));
+        }
+        else if (prop.schemaRef) {
+            builder.push(this.indent(`"@schema": ${prop.schemaRef},`));
+        }
+        const flags = ["optional", "array", "multilang", "inverse"];
+        for (const flag of flags) {
+            if (prop[flag]) {
+                builder.push(this.indent(`"@${flag}": true,`));
+            }
+        }
+        builder.push("},");
+        return builder.join("\n");
+    }
+    printType(schema) {
+        if (schema.type.length === 0) {
+            return null;
+        }
+        if (schema.type.length === 1) {
+            return `"@type": ${this.printPrefixed(schema.type[0])},`;
+        }
+        return [
+            `"@type": [`,
+            ...schema.type.map((type) => `  ${this.printPrefixed(type)},`),
+            `],`,
+        ].join("\n");
+    }
+    printPrefix(namespace) {
+        return namespace.$prefix.substring(0, namespace.$prefix.length - 1);
+    }
+    printPrefixed(value) {
+        if (value === "@id") {
+            return `${this.printPrefix(ldkit)}.IRI`;
+        }
+        for (const namespace of NAMESPACES) {
+            if (value.startsWith(namespace.$iri)) {
+                return `${this.printPrefix(namespace)}.${value.substring(namespace.$iri.length)}`;
+            }
+        }
+        return `"${value}"`;
+    }
+    printKey(key) {
+        if (key.match(/^[a-zA-Z0-9_]+$/)) {
+            return key;
+        }
+        return `"${key}"`;
+    }
+    indent(text) {
+        if (text === null) {
+            return null;
+        }
+        return text.split("\n")
+            .map((line) => `${this.space}${line}`)
+            .join("\n");
+    }
+}

package/esm/scripts/shex_to_schema.d.ts

@@ -0,0 +1,6 @@
+import { SchemaSpec } from "./schema_to_script.js";
+import type { Schema as ShexSchema } from "./shexj_types.js";
+export declare function shexcToShexj(shexc: string): ShexSchema;
+export declare function shexjToSchema(shexj: ShexSchema): SchemaSpec[];
+export declare function shexcToSchema(shexc: string): SchemaSpec[];
+//# sourceMappingURL=shex_to_schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shex_to_schema.d.ts","sourceRoot":"","sources":["../../src/scripts/shex_to_schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,KAAK,EAEV,MAAM,IAAI,UAAU,EAMrB,MAAM,kBAAkB,CAAC;AAG1B,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAItD;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,EAAE,CAG7D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,EAAE,CAGzD"}

package/esm/scripts/shex_to_schema.js

@@ -0,0 +1,233 @@
+import ShexParser from "@shexjs/parser";
+import { ldkit, rdf } from "../namespaces.js";
+export function shexcToShexj(shexc) {
+    // Parse the Shexc string using the ShexJS parser
+    const baseIri = "";
+    return ShexParser.construct(baseIri).parse(shexc);
+}
+export function shexjToSchema(shexj) {
+    const converter = new ShexConverter();
+    return converter.process(shexj);
+}
+export function shexcToSchema(shexc) {
+    const shexj = shexcToShexj(shexc);
+    return shexjToSchema(shexj);
+}
+class ShexConverter {
+    constructor() {
+        Object.defineProperty(this, "schemas", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "shexj", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "idMapping", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+    }
+    process(shexj) {
+        this.shexj = shexj;
+        this.buildIdMapping();
+        this.visit(this.shexj, {});
+        return [...this.schemas.values()];
+    }
+    visit(nodeOrRef, context) {
+        if (nodeOrRef === undefined) {
+            return;
+        }
+        const isRef = typeof nodeOrRef === "string";
+        const node = isRef ? this.idMapping.get(nodeOrRef) : nodeOrRef;
+        if (typeof node !== "object" || node === null) {
+            return;
+        }
+        if (Array.isArray(node)) {
+            for (const item of node) {
+                this.visit(item, context);
+            }
+            return;
+        }
+        switch (node.type) {
+            case "Schema":
+                if (!node.shapes) {
+                    throw new Error("No shapes found in ShexJ schema");
+                }
+                this.visit(node.shapes, {});
+                break;
+            case "ShapeDecl":
+                if (context.shapeAnd || context.shapeOr) {
+                    this.visit(node.shapeExpr, context);
+                }
+                else if (isRef) {
+                    context.property.schemaRef = this.getSuffix(node.id);
+                }
+                else {
+                    const schema = this.createSchema(node.id);
+                    this.visit(node.shapeExpr, { schema });
+                }
+                break;
+            case "Shape":
+                if (context.property) {
+                    const schema = this.createAnonymousSchema();
+                    context.property.schema = schema;
+                    this.visit(node.expression, {
+                        ...context,
+                        property: undefined,
+                        schema,
+                    });
+                }
+                else {
+                    const schema = context.schema ??
+                        this.createSchema(node.id);
+                    this.visit(node.expression, { ...context, schema });
+                }
+                break;
+            case "ShapeAnd": {
+                const root = !context.shapeAnd && !context.shapeOr;
+                const schema = root ? this.createAnonymousSchema() : context.schema;
+                if (root) {
+                    if (context.property) {
+                        context.property.schema = schema;
+                    }
+                    this.visit(node.shapeExprs, {
+                        schema,
+                        shapeAnd: true,
+                    });
+                }
+                else {
+                    this.visit(node.shapeExprs, { ...context, shapeAnd: true, schema });
+                }
+                break;
+            }
+            case "ShapeOr": {
+                const root = !context.shapeAnd && !context.shapeOr;
+                const schema = root ? this.createAnonymousSchema() : context.schema;
+                if (root) {
+                    if (context.property) {
+                        context.property.schema = schema;
+                    }
+                    this.visit(node.shapeExprs, {
+                        schema,
+                        shapeOr: true,
+                    });
+                }
+                else {
+                    this.visit(node.shapeExprs, { ...context, shapeOr: true, schema });
+                }
+                break;
+            }
+            case "EachOf":
+                this.visit(node.expressions, context);
+                break;
+            case "OneOf":
+                this.visit(node.expressions, { ...context, optional: true });
+                break;
+            case "TripleConstraint": {
+                if (node.predicate === rdf.type) {
+                    if (!context.shapeOr) {
+                        this.visit(node.valueExpr, { ...context, type: true });
+                    }
+                    break;
+                }
+                const property = {
+                    id: node.predicate,
+                };
+                if (node.min === 0 || context.optional || context.shapeOr) {
+                    property.optional = true;
+                }
+                if (node.max && node.max > 1 || node.max === -1) {
+                    property.array = true;
+                }
+                if (node.inverse) {
+                    property.inverse = true;
+                }
+                const name = this.getSuffix(node.predicate);
+                context.schema.properties[name] = property;
+                this.visit(node.valueExpr, { ...context, property });
+                break;
+            }
+            case "NodeConstraint": {
+                if (context.type) {
+                    if (node.values?.length) {
+                        context.schema.type.push(node.values[0]);
+                    }
+                }
+                else if (context.property) {
+                    const property = context.property;
+                    if (node.nodeKind === "iri") { // IRI
+                        property.type = ldkit.IRI;
+                    }
+                    else if (node.datatype) { // literal
+                        property.type = node.datatype;
+                    }
+                    else if (node.values?.length) { // enumeration
+                        const first = node.values[0];
+                        if (typeof first === "string") {
+                            property.type = ldkit.IRI;
+                        }
+                        else if (typeof first === "object" && first.type !== undefined) {
+                            property.type = first.type;
+                        }
+                    }
+                }
+                break;
+            }
+        }
+    }
+    createSchema(id) {
+        if (this.schemas.has(id)) {
+            throw new Error(`Duplicate schema ID: ${id}`);
+        }
+        const name = this.getSuffix(id);
+        const schema = {
+            name,
+            type: [],
+            properties: {},
+        };
+        this.schemas.set(id, schema);
+        return schema;
+    }
+    createAnonymousSchema() {
+        return {
+            name: "AnonymousSchema",
+            type: [],
+            properties: {},
+        };
+    }
+    buildIdMapping() {
+        const queue = [this.shexj];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (Array.isArray(current)) {
+                for (const item of current) {
+                    queue.push(item);
+                }
+            }
+            else if (typeof current === "object" && current !== null) {
+                for (const [key, value] of Object.entries(current)) {
+                    if (key === "id") {
+                        this.idMapping.set(value, current);
+                    }
+                    else if (typeof value === "object") {
+                        queue.push(value);
+                    }
+                }
+            }
+        }
+    }
+    getSuffix(value) {
+        const cutoff = Math.max(value.lastIndexOf("#"), value.lastIndexOf("/"));
+        if (cutoff === -1) {
+            return value;
+        }
+        return value.substring(cutoff + 1);
+    }
+}