@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/_ObjectType/sparqlFunctionDeclarations.js

@@ -1,166 +0,0 @@
-import { camelCase } from "change-case";
-import { StructureKind } from "ts-morph";
-import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { sparqlConstructQueryFunctionDeclaration } from "./sparqlConstructQueryFunctionDeclaration.js";
-import { sparqlConstructQueryStringFunctionDeclaration } from "./sparqlConstructQueryStringFunctionDeclaration.js";
-export function sparqlFunctionDeclarations() {
-    if (!this.features.has("sparql")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    const variables = {
-        preferredLanguages: "parameters?.preferredLanguages",
-        subject: "subject",
-        variablePrefix: "variablePrefix",
-    };
-    const rdfClassVariable = `dataFactory.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = `dataFactory.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
-    const subjectDefault = camelCase(this.name);
-    const sparqlConstructTemplateTriplesStatements = [
-        `const subject = parameters?.subject ?? dataFactory.variable!("${subjectDefault}");`,
-        "const triples: sparqljs.Triple[] = []",
-        `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
-    ];
-    let nop = true;
-    const sparqlWherePatternsStatements = [
-        "const optionalPatterns: sparqljs.OptionalPattern[] = [];",
-        "const requiredPatterns: sparqljs.Pattern[] = [];",
-        `const subject = parameters?.subject ?? dataFactory.variable!("${subjectDefault}");`,
-        `const variablePrefix = parameters?.variablePrefix ?? (subject.termType === "Variable" ? subject.value : "${subjectDefault}");`,
-    ];
-    for (const parentObjectType of this.parentObjectTypes) {
-        sparqlConstructTemplateTriplesStatements.push(`triples.push(...${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType: true, subject, variablePrefix }));`);
-        sparqlWherePatternsStatements.push(`\
-for (const pattern of ${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType: true, subject, variablePrefix })) {
-  if (pattern.type === "optional") {
-    optionalPatterns.push(pattern);
-  } else {
-    requiredPatterns.push(pattern);
-  }
-}`);
-        nop = false;
-    }
-    if (this.fromRdfType.isJust()) {
-        const fromRdfTypeVariables = this.fromRdfTypeVariable
-            .toList()
-            .concat(this.descendantFromRdfTypeVariables);
-        sparqlConstructTemplateTriplesStatements.push(`\
-if (!parameters?.ignoreRdfType) {
-  triples.push(
-    { subject, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
-    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
-  );
-}`);
-        sparqlWherePatternsStatements.push(`const rdfTypeVariable = ${rdfTypeVariable};`, `\
-if (!parameters?.ignoreRdfType) {
-  requiredPatterns.push(
-    ${fromRdfTypeVariables.length > 1
-            ? `\
-    {
-      type: "values" as const,
-      values: [${fromRdfTypeVariables.join(", ")}].map((identifier) => {
-        const valuePatternRow: sparqljs.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as rdfjs.NamedNode;
-        return valuePatternRow;
-      }),
-    },
-    ${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: dataFactory.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject }),`
-            : `${syntheticNamePrefix}sparqlInstancesOfPattern({ rdfType: ${fromRdfTypeVariables[0]}, subject }),`}
-    {
-      triples: [
-        {
-          subject,
-          predicate: ${rdfjsTermExpression(rdf.type)},
-          object: rdfTypeVariable
-        }
-      ],
-      type: "bgp" as const
-    }
-  );
-  optionalPatterns.push({
-    patterns: [
-      {
-        triples: [
-          {
-            subject: rdfTypeVariable,
-            predicate: {
-              items: [${rdfjsTermExpression(rdfs.subClassOf)}],
-              pathType: "+" as const,
-              type: "path" as const
-            },
-            object: ${rdfClassVariable}
-          }
-        ],
-        type: "bgp" as const
-      }
-    ],
-    type: "optional" as const
-  });
-}`);
-        nop = false;
-    }
-    const propertySparqlWherePatterns = [];
-    for (const property of this.ownProperties) {
-        if (property.recursive) {
-            continue;
-        }
-        for (const triple of property.sparqlConstructTemplateTriples({
-            variables,
-        })) {
-            sparqlConstructTemplateTriplesStatements.push(`triples.push(${triple});`);
-            nop = false;
-        }
-        propertySparqlWherePatterns.push(...property.sparqlWherePatterns({ variables }));
-    }
-    if (propertySparqlWherePatterns.length > 0) {
-        sparqlWherePatternsStatements.push(`\
-const propertyPatterns: readonly sparqljs.Pattern[] = [${propertySparqlWherePatterns.join(", ")}];
-for (const pattern of propertyPatterns) {
-  if (pattern.type === "optional") {
-    optionalPatterns.push(pattern);
-  } else {
-    requiredPatterns.push(pattern);
-  }  
-}`);
-        nop = false;
-    }
-    sparqlConstructTemplateTriplesStatements.push("return triples;");
-    sparqlWherePatternsStatements.push("return requiredPatterns.concat(optionalPatterns);");
-    return [
-        sparqlConstructQueryFunctionDeclaration.bind(this)(),
-        sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
-        {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}sparqlConstructTemplateTriples`,
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: `${nop ? "_" : ""}parameters`,
-                    type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
-                },
-            ],
-            returnType: "readonly sparqljs.Triple[]",
-            statements: nop ? "return [];" : sparqlConstructTemplateTriplesStatements,
-        },
-        {
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}sparqlWherePatterns`,
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: `${nop ? "_" : ""}parameters`,
-                    type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
-                },
-            ],
-            returnType: "readonly sparqljs.Pattern[]",
-            statements: nop ? "return [];" : sparqlWherePatternsStatements,
-        },
-    ];
-}
-//# sourceMappingURL=sparqlFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/toJsonFunctionOrMethodDeclaration.d.ts

@@ -1,10 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function toJsonFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
-    name: string;
-    parameters: OptionalKind<ParameterDeclarationStructure>[];
-    returnType: string;
-    statements: string[];
-}>;
-//# sourceMappingURL=toJsonFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/toRdfFunctionOrMethodDeclaration.d.ts

@@ -1,10 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { OptionalKind, ParameterDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function toRdfFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
-    name: string;
-    parameters: OptionalKind<ParameterDeclarationStructure>[];
-    returnType: string;
-    statements: string[];
-}>;
-//# sourceMappingURL=toRdfFunctionOrMethodDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/toRdfFunctionOrMethodDeclaration.js

@@ -1,76 +0,0 @@
-import { Maybe } from "purify-ts";
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function toRdfFunctionOrMethodDeclaration() {
-    if (!this.features.has("rdf")) {
-        return Maybe.empty();
-    }
-    this.ensureAtMostOneSuperObjectType();
-    const parameters = [];
-    if (this.declarationType === "interface") {
-        parameters.push({
-            name: this.thisVariable,
-            type: this.name,
-        });
-    }
-    parameters.push({
-        hasQuestionToken: true,
-        name: "options",
-        type: `{ ${variables.ignoreRdfType}?: boolean; ${variables.mutateGraph}?: rdfjsResource.MutableResource.MutateGraph, ${variables.resourceSet}?: rdfjsResource.MutableResourceSet }`,
-    });
-    let usedIgnoreRdfTypeVariable = false;
-    const statements = [
-        `const ${variables.mutateGraph} = options?.${variables.mutateGraph};`,
-        `const ${variables.resourceSet} = options?.${variables.resourceSet} ?? new rdfjsResource.MutableResourceSet({ dataFactory, dataset: datasetFactory.dataset() });`,
-    ];
-    if (this.parentObjectTypes.length > 0) {
-        const superToRdfOptions = `{ ${variables.ignoreRdfType}: true, ${variables.mutateGraph}, ${variables.resourceSet} }`;
-        let superToRdfCall;
-        switch (this.declarationType) {
-            case "class":
-                superToRdfCall = `super.${syntheticNamePrefix}toRdf(${superToRdfOptions})`;
-                break;
-            case "interface":
-                superToRdfCall = `${this.parentObjectTypes[0].staticModuleName}.${syntheticNamePrefix}toRdf(${this.thisVariable}, ${superToRdfOptions})`;
-                break;
-        }
-        statements.push(`const ${variables.resource} = ${superToRdfCall};`);
-        usedIgnoreRdfTypeVariable = !this.parentObjectTypes[0].abstract;
-    }
-    else if (this.identifierType.isNamedNodeKind) {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableNamedResource(${this.thisVariable}.${this.identifierProperty.name}, { ${variables.mutateGraph} });`);
-    }
-    else {
-        statements.push(`const ${variables.resource} = ${variables.resourceSet}.mutableResource(${this.thisVariable}.${this.identifierProperty.name}, { ${variables.mutateGraph} });`);
-    }
-    if (this.toRdfTypes.length > 0) {
-        statements.push(`if (!${variables.ignoreRdfType}) { ${this.toRdfTypes.map((toRdfType) => `${variables.resource}.add(${rdfjsTermExpression(rdf.type)}, ${variables.resource}.dataFactory.namedNode("${toRdfType.value}"));`).join(" ")} }`);
-        usedIgnoreRdfTypeVariable = true;
-    }
-    for (const property of this.properties) {
-        statements.push(...property.toRdfStatements({
-            variables: {
-                ...variables,
-                value: `${this.thisVariable}.${property.name}`,
-            },
-        }));
-    }
-    statements.push(`return ${variables.resource};`);
-    if (usedIgnoreRdfTypeVariable) {
-        statements.unshift(`const ${variables.ignoreRdfType} = !!options?.ignoreRdfType;`);
-    }
-    return Maybe.of({
-        name: `${syntheticNamePrefix}toRdf`,
-        parameters,
-        returnType: this.toRdfjsResourceType,
-        statements,
-    });
-}
-const variables = {
-    ignoreRdfType: "ignoreRdfType",
-    mutateGraph: "mutateGraph",
-    resource: "resource",
-    resourceSet: "resourceSet",
-};
-//# sourceMappingURL=toRdfFunctionOrMethodDeclaration.js.map

package/dist/generators/ts/forwardingObjectSetClassDeclaration.d.ts

@@ -1,8 +0,0 @@
-import { type ClassDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-export declare function forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
-    objectTypes: readonly ObjectType[];
-    objectUnionTypes: readonly ObjectUnionType[];
-}): ClassDeclarationStructure;
-//# sourceMappingURL=forwardingObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/forwardingObjectSetClassDeclaration.js

@@ -1,29 +0,0 @@
-import { Scope, StructureKind } from "ts-morph";
-import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export function forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
-    const delegateName = `${syntheticNamePrefix}delegate`;
-    return {
-        getAccessors: [
-            {
-                isAbstract: true,
-                name: delegateName,
-                scope: Scope.Protected,
-                returnType: `${syntheticNamePrefix}ObjectSet`,
-            },
-        ],
-        implements: [`${syntheticNamePrefix}ObjectSet`],
-        isAbstract: true,
-        isExported: true,
-        kind: StructureKind.Class,
-        name: `${syntheticNamePrefix}ForwardingObjectSet`,
-        methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })).map((methodSignature) => ({
-            ...methodSignature,
-            kind: StructureKind.Method,
-            statements: [
-                `return this.${delegateName}.${methodSignature.name}(${methodSignature.parameters.map((parameter) => parameter.name).join(", ")});`,
-            ],
-        }))),
-    };
-}
-//# sourceMappingURL=forwardingObjectSetClassDeclaration.js.map

package/dist/generators/ts/objectInitializer.d.ts

@@ -1,2 +0,0 @@
-export declare function objectInitializer(properties: Record<string, boolean | number | string | undefined>): string;
-//# sourceMappingURL=objectInitializer.d.ts.map

package/dist/generators/ts/objectInitializer.js

@@ -1,14 +0,0 @@
-export function objectInitializer(properties) {
-    return `{ ${Object.entries(properties)
-        .flatMap(([propertyName, propertyValue]) => {
-        if (typeof propertyValue === "undefined") {
-            return [];
-        }
-        if (typeof propertyValue === "string" && propertyName === propertyValue) {
-            return [propertyName];
-        }
-        return [`${propertyName}: ${propertyValue}`];
-    })
-        .join(", ")} }`;
-}
-//# sourceMappingURL=objectInitializer.js.map

package/dist/input/PropertyPath.d.ts

@@ -1,41 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-import { Either } from "purify-ts";
-import { Resource } from "rdfjs-resource";
-export interface AlternativePath {
-    readonly kind: "AlternativePath";
-    readonly members: readonly PropertyPath[];
-}
-export interface InversePath {
-    readonly kind: "InversePath";
-    readonly path: PropertyPath;
-}
-export interface OneOrMorePath {
-    readonly kind: "OneOrMorePath";
-    readonly path: PropertyPath;
-}
-export interface PredicatePath {
-    readonly iri: NamedNode;
-    readonly kind: "PredicatePath";
-}
-export interface SequencePath {
-    readonly kind: "SequencePath";
-    readonly members: readonly PropertyPath[];
-}
-export interface ZeroOrMorePath {
-    readonly kind: "ZeroOrMorePath";
-    readonly path: PropertyPath;
-}
-export interface ZeroOrOnePath {
-    readonly kind: "ZeroOrOnePath";
-    readonly path: PropertyPath;
-}
-export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
-export declare namespace PropertyPath {
-    function $fromRdf(resource: Resource, _?: {
-        [_index: string]: any;
-        ignoreRdfType?: boolean;
-        preferredLanguages?: readonly string[];
-    }): Either<Error, PropertyPath>;
-    function $toRdf(_propertyPath: PropertyPath, _options?: any): Resource;
-}
-//# sourceMappingURL=PropertyPath.d.ts.map

package/dist/input/PropertyPath.js

@@ -1,95 +0,0 @@
-import { rdf, sh } from "@tpluscode/rdf-ns-builders";
-import { Either, Left } from "purify-ts";
-import { Resource } from "rdfjs-resource";
-export var PropertyPath;
-(function (PropertyPath) {
-    function $fromRdf(resource, _) {
-        // Predicate path
-        // sh:path ex:parent
-        if (resource.identifier.termType === "NamedNode") {
-            return Either.of({ iri: resource.identifier, kind: "PredicatePath" });
-        }
-        // The other property path types are BlankNodes
-        const getPropertyPathList = (listResource) => {
-            return listResource.toList().chain((values) => {
-                const members = [];
-                for (const value of values) {
-                    const memberResource = value.toResource().toMaybe();
-                    if (memberResource.isNothing()) {
-                        return Left(new Error(`non-identifier in property path list ${Resource.Identifier.toString(listResource.identifier)}`));
-                    }
-                    const member = PropertyPath.$fromRdf(memberResource.unsafeCoerce());
-                    if (member.isLeft()) {
-                        return member;
-                    }
-                    members.push(member.unsafeCoerce());
-                }
-                return Either.of(members);
-            });
-        };
-        for (const quad of resource.dataset.match(resource.identifier, null, null, null)) {
-            switch (quad.object.termType) {
-                case "BlankNode":
-                case "NamedNode":
-                    break;
-                default:
-                    return Left(new Error(`non-BlankNode/NamedNode property path object on path ${Resource.Identifier.toString(resource.identifier)}: ${quad.object.termType} ${quad.object.value}`));
-            }
-            const objectResource = new Resource({
-                dataset: resource.dataset,
-                identifier: quad.object,
-            });
-            // Alternative path
-            // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
-            if (quad.predicate.equals(sh.alternativePath)) {
-                return getPropertyPathList(objectResource).map((members) => ({
-                    kind: "AlternativePath",
-                    members,
-                }));
-            }
-            // Inverse path
-            // sh:path: [ sh:inversePath ex:parent ]
-            if (quad.predicate.equals(sh.inversePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "InversePath",
-                    path,
-                }));
-            }
-            // One or more path
-            if (quad.predicate.equals(sh.oneOrMorePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "OneOrMorePath",
-                    path,
-                }));
-            }
-            // Sequence path
-            // sh:path ( ex:parent ex:firstName )
-            if (quad.predicate.equals(rdf.first)) {
-                return getPropertyPathList(objectResource).map((members) => ({
-                    kind: "SequencePath",
-                    members,
-                }));
-            }
-            // Zero or more path
-            if (quad.predicate.equals(sh.zeroOrMorePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "ZeroOrMorePath",
-                    path,
-                }));
-            }
-            if (quad.predicate.equals(sh.zeroOrOnePath)) {
-                return PropertyPath.$fromRdf(objectResource).map((path) => ({
-                    kind: "ZeroOrOnePath",
-                    path,
-                }));
-            }
-        }
-        return Left(new Error(`unrecognized or ill-formed SHACL property path ${Resource.Identifier.toString(resource.identifier)}`));
-    }
-    PropertyPath.$fromRdf = $fromRdf;
-    function $toRdf(_propertyPath, _options) {
-        throw new Error("not implemented");
-    }
-    PropertyPath.$toRdf = $toRdf;
-})(PropertyPath || (PropertyPath = {}));
-//# sourceMappingURL=PropertyPath.js.map