@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/_ObjectType/IdentifierProperty.js

@@ -1,58 +1,122 @@
 import { Maybe } from "purify-ts";
-import { Scope, } from "ts-morph";
-import { MintingStrategy } from "../../../ast";
+import { invariant } from "ts-invariant";
+import { Import } from "../Import.js";
+import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    constructor({ mintingStrategy, ...superParameters }) {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "purifyHelpers.Equatable.booleanEquals";
-        this.mintingStrategy = mintingStrategy;
-    }
-    get classConstructorParametersPropertySignature() {
-        return Maybe.of({
-            hasQuestionToken: this.mintingStrategy.isJust(),
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
+        this.equalsFunction = "booleanEquals";
+        this.mutable = false;
+        invariant(this.visibility === "public");
+        this.abstract = abstract;
+        this.classDeclarationVisibility = classDeclarationVisibility;
+        if (mintingStrategy.isJust()) {
+            this.mintingStrategy = mintingStrategy.unsafeCoerce();
+        }
+        else if (this.type.nodeKinds.has("BlankNode")) {
+            this.mintingStrategy = "blankNode";
+        }
+        else {
+            this.mintingStrategy = "none";
+        }
+        this.lazyObjectTypeMutable = lazyObjectTypeMutable;
+        this.override = override;
     }
     get classGetAccessorDeclaration() {
-        if (!this.mintingStrategy.isJust()) {
+        if (this.abstract) {
             return Maybe.empty();
         }
         let mintIdentifier;
-        switch (this.mintingStrategy.unsafeCoerce()) {
-            case MintingStrategy.SHA256:
+        switch (this.mintingStrategy) {
+            case "blankNode":
+                mintIdentifier = "dataFactory.blankNode()";
+                break;
+            case "none":
+                // If there's no minting strategy the identifier will be required by the constructor and assigned to a public property.
+                return Maybe.empty();
+            case "sha256":
                 mintIdentifier =
                     "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${this.hash(sha256.create())}`)";
                 break;
-            case MintingStrategy.UUIDv4:
+            case "uuidv4":
                 mintIdentifier =
                     "dataFactory.namedNode(`urn:shaclmate:object:${this.type}:${uuid.v4()}`)";
                 break;
         }
         return Maybe.of({
+            leadingTrivia: this.override ? "override " : undefined,
             name: this.name,
             returnType: this.type.name,
             statements: [
-                `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`,
+                this.lazyObjectTypeMutable()
+                    ? `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`
+                    : `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`,
             ],
         });
     }
     get classPropertyDeclaration() {
-        if (this.mintingStrategy.isJust()) {
-            // Mutable _identifier that will be lazily initialized by the getter
-            return {
-                name: `_${this.name}`,
-                scope: Scope.Private,
-                type: `${this.type.name} | undefined`,
-            };
+        if (this.abstract) {
+            // Abstract version of the accessor
+            // Work around a ts-morph bug that puts the override keyword before the abstract keyword
+            return Maybe.of({
+                hasOverrideKeyword: this.abstract && this.override ? undefined : this.override,
+                isAbstract: this.abstract && this.override ? undefined : this.abstract,
+                isReadonly: true,
+                leadingTrivia: this.abstract && this.override ? "abstract override " : undefined,
+                name: this.name,
+                type: this.type.name,
+            });
         }
-        return {
+        // See note in TypeFactory re: the logic of whether to declare the identifier in the class or not.
+        if (!this.classDeclarationVisibility.isJust()) {
+            return Maybe.empty();
+        }
+        switch (this.mintingStrategy) {
+            case "none":
+                // Immutable, public identifier property, no getter
+                return Maybe.of({
+                    isReadonly: true,
+                    name: this.name,
+                    type: this.type.name,
+                });
+            default:
+                // Mutable _identifier property that will be lazily initialized by the getter to mint the identifier
+                return Maybe.of({
+                    name: `_${this.name}`,
+                    scope: this.classDeclarationVisibility
+                        .map(Property.visibilityToScope)
+                        .unsafeCoerce(),
+                    type: `${this.type.name} | undefined`,
+                });
+        }
+    }
+    get constructorParametersPropertySignature() {
+        if (this.objectType.declarationType === "class" && this.abstract) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            hasQuestionToken: this.objectType.declarationType === "class" &&
+                this.mintingStrategy !== "none",
             isReadonly: true,
             name: this.name,
             type: this.type.name,
-        };
+        });
+    }
+    get declarationImports() {
+        const imports = this.type.useImports().concat();
+        if (this.objectType.features.has("hash") &&
+            this.objectType.declarationType === "class") {
+            switch (this.mintingStrategy) {
+                case "sha256":
+                    imports.push(Import.SHA256);
+                    break;
+                case "uuidv4":
+                    imports.push(Import.UUID);
+                    break;
+            }
+        }
+        return imports;
     }
     get interfacePropertySignature() {
         return {
@@ -61,19 +125,76 @@ export class IdentifierProperty extends Property {
             type: this.type.name,
         };
     }
+    get jsonPropertySignature() {
+        return {
+            isReadonly: true,
+            name: "@id",
+            type: "string",
+        };
+    }
+    get snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
     classConstructorStatements({ variables, }) {
+        if (this.abstract) {
+            return [];
+        }
+        return this.classPropertyDeclaration
+            .map((classPropertyDeclaration) => [
+            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
+        ])
+            .orDefault([]);
+    }
+    fromJsonStatements({ variables, }) {
         return [
-            `this.${this.mintingStrategy.isJust() ? "_" : ""}${this.name} = ${variables.parameter};`,
+            `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
     fromRdfStatements({ variables, }) {
         return [`const ${this.name} = ${variables.resource}.identifier`];
     }
-    hashStatements(parameters) {
-        return this.type.hashStatements(parameters);
+    hashStatements() {
+        return [];
+    }
+    interfaceConstructorStatements({ variables, }) {
+        return [`const ${this.name} = ${variables.parameter}`];
     }
-    sparqlGraphPatternExpression() {
-        return Maybe.empty();
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.name}\`, type: "Control" }`);
+    }
+    jsonZodSchema({ variables, }) {
+        return {
+            key: this.jsonPropertySignature.name,
+            schema: `${variables.zod}.string().min(1)`,
+        };
+    }
+    sparqlConstructTemplateTriples() {
+        return [];
+    }
+    sparqlWherePatterns() {
+        return [];
+    }
+    toJsonObjectMember({ variables, }) {
+        const nodeKinds = [...this.type.nodeKinds];
+        const valueToNodeKinds = nodeKinds.map((nodeKind) => {
+            switch (nodeKind) {
+                case "BlankNode":
+                    return `\`_:\${${variables.value}.value}\``;
+                case "NamedNode":
+                    return `${variables.value}.value`;
+                default:
+                    throw new RangeError(nodeKind);
+            }
+        });
+        if (valueToNodeKinds.length === 1) {
+            return `"@id": ${valueToNodeKinds[0]}`;
+        }
+        invariant(valueToNodeKinds.length === 2);
+        return `"@id": ${variables.value}.termType === "${nodeKinds[0]}" ? ${valueToNodeKinds[0]} : ${valueToNodeKinds[1]}`;
     }
     toRdfStatements() {
         return [];

package/generators/ts/_ObjectType/Property.d.ts

@@ -1,38 +1,168 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { Configuration } from "../Configuration.js";
+import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure, Scope } from "ts-morph";
+import type { PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../../../enums/index.js";
+import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 export declare abstract class Property<TypeT extends {
+    readonly mutable: boolean;
     readonly name: string;
 }> {
-    abstract readonly classConstructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    /**
+     * Optional get accessor to include in a class declaration of the object type.
+     */
     abstract readonly classGetAccessorDeclaration: Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    abstract readonly classPropertyDeclaration: OptionalKind<PropertyDeclarationStructure>;
+    /**
+     * Optional property declaration to include in a class declaration of the object type.
+     */
+    abstract readonly classPropertyDeclaration: Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    /**
+     * Optional property to include in the parameters object of a class constructor.
+     */
+    abstract readonly constructorParametersPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    /**
+     * Function declaration that takes two values of the property and compares them, returning and EqualsResult.
+     */
     abstract readonly equalsFunction: string;
+    /**
+     * Signature of the property in an interface version of the object.
+     */
     abstract readonly interfacePropertySignature: OptionalKind<PropertySignatureStructure>;
+    /**
+     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
+     */
+    abstract readonly jsonPropertySignature: OptionalKind<PropertySignatureStructure>;
+    /**
+     * Is the property reassignable?
+     */
+    abstract readonly mutable: boolean;
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
     readonly name: string;
+    /**
+     * Reusable function, type, and other declarations that are not particular to this property but that property-specific code
+     * relies on. For example, the equals function/method of ObjectType has a custom return type that's the same across all
+     * ObjectType's. Instead of re-declaring the return type anonymously on every equals function, declare a named type
+     * as a snippet and reference it.
+     *
+     * The generator deduplicates snippet declarations across all types before adding them to the source.
+     */
+    abstract readonly snippetDeclarations: readonly string[];
+    /**
+     * Property type
+  .   */
     readonly type: TypeT;
-    protected readonly configuration: Configuration;
-    constructor({ configuration, name, type, }: {
-        configuration: Configuration;
+    /**
+     * Property visibility: private, protected, public.
+     */
+    readonly visibility: PropertyVisibility;
+    protected readonly dataFactoryVariable: string;
+    protected readonly objectType: {
+        readonly declarationType: TsObjectDeclarationType;
+        readonly features: Set<TsFeature>;
+    };
+    constructor({ dataFactoryVariable, name, objectType, type, visibility, }: {
+        dataFactoryVariable: string;
         name: string;
+        objectType: Property<TypeT>["objectType"];
         type: TypeT;
+        visibility: PropertyVisibility;
     });
-    get importStatements(): readonly string[];
+    /**
+     * Imports this property requires when declared in an object.
+     */
+    get declarationImports(): readonly Import[];
+    protected static visibilityToScope(visibility: PropertyVisibility): Scope | undefined;
+    /**
+     * Statements to assign the parameter of described by constructorParametersPropertySignature to a class member.
+     */
     abstract classConstructorStatements(parameters: {
         variables: {
             parameter: string;
         };
     }): readonly string[];
+    /**
+     * Statements to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
+     */
+    abstract fromJsonStatements(parameters: {
+        variables: {
+            jsonObject: string;
+        };
+    }): readonly string[];
+    /**
+     * Statements to deserialize RDF for this property to a typed value of the property.
+     */
     abstract fromRdfStatements(parameters: {
         variables: {
+            context: string;
+            languageIn: string;
             resource: string;
         };
     }): readonly string[];
+    /**
+     * Statements to hash this property using a hasher instance.
+     */
     abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    abstract sparqlGraphPatternExpression(): Maybe<string>;
+    /**
+     * Companion to classConstructorStatements with a similar purpose in an interface's create() function.
+     */
+    abstract interfaceConstructorStatements(parameters: {
+        variables: {
+            parameter: string;
+        };
+    }): readonly string[];
+    /**
+     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
+     */
+    abstract jsonUiSchemaElement(parameters: {
+        variables: {
+            scopePrefix: string;
+        };
+    }): Maybe<string>;
+    /**
+     * zod Object key: schema pair on the property serialized by toJsonObjectMember.
+     */
+    abstract jsonZodSchema(parameters: {
+        variables: {
+            zod: string;
+        };
+    }): {
+        readonly key: string;
+        readonly schema: string;
+    };
+    /**
+     * An array of SPARQL.js CONSTRUCT template triples for this property as strings (so they can incorporate runtime calls).
+     */
+    abstract sparqlConstructTemplateTriples(parameters: {
+        variables: {
+            subject: string;
+            variablePrefix: string;
+        };
+    }): readonly string[];
+    /**
+     * An array of SPARQL.js where patterns for this property as strings (so they can incorporate runtime calls).
+     */
+    abstract sparqlWherePatterns(parameters: {
+        variables: {
+            subject: string;
+            variablePrefix: string;
+        };
+    }): readonly string[];
+    /**
+     * property: expression to serialize a property to a JSON object member.
+     */
+    abstract toJsonObjectMember(parameters: {
+        variables: {
+            value: string;
+        };
+    }): string;
+    /**
+     * Statements to serialize this property to an RDF resource.
+     */
     abstract toRdfStatements(parameters: {
         variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "predicate">;
     }): readonly string[];
+    protected rdfjsTermExpression(rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">): string;
 }
 //# sourceMappingURL=Property.d.ts.map

package/generators/ts/_ObjectType/Property.js

@@ -1,11 +1,34 @@
+import { Scope, } from "ts-morph";
+import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
-    constructor({ configuration, name, type, }) {
-        this.configuration = configuration;
+    constructor({ dataFactoryVariable, name, objectType, type, visibility, }) {
+        this.dataFactoryVariable = dataFactoryVariable;
         this.name = name;
+        this.objectType = objectType;
         this.type = type;
+        this.visibility = visibility;
     }
-    get importStatements() {
+    /**
+     * Imports this property requires when declared in an object.
+     */
+    get declarationImports() {
         return [];
     }
+    static visibilityToScope(visibility) {
+        switch (visibility) {
+            case "private":
+                return Scope.Private;
+            case "protected":
+                return Scope.Protected;
+            case "public":
+                return undefined;
+        }
+    }
+    rdfjsTermExpression(rdfjsTerm) {
+        return rdfjsTermExpression({
+            dataFactoryVariable: this.dataFactoryVariable,
+            rdfjsTerm,
+        });
+    }
 }
 //# sourceMappingURL=Property.js.map

package/generators/ts/_ObjectType/ShaclProperty.d.ts

@@ -1,25 +1,44 @@
 import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
+import type { IdentifierType } from "../IdentifierType.js";
+import type { Import } from "../Import.js";
 import type { Type } from "../Type.js";
 import { Property } from "./Property.js";
 export declare class ShaclProperty extends Property<Type> {
+    readonly mutable: boolean;
+    private readonly comment;
+    private readonly description;
+    private readonly label;
     private readonly path;
-    constructor({ path, ...superParameters }: {
+    constructor({ comment, description, label, mutable, path, ...superParameters }: {
+        comment: Maybe<string>;
+        description: Maybe<string>;
+        label: Maybe<string>;
+        mutable: boolean;
         path: rdfjs.NamedNode;
         type: Type;
     } & ConstructorParameters<typeof Property>[0]);
-    get classConstructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
     get classGetAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get classPropertyDeclaration(): OptionalKind<PropertyDeclarationStructure>;
+    get classPropertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
+    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get declarationImports(): readonly Import[];
     get equalsFunction(): string;
-    get importStatements(): readonly string[];
     get interfacePropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get jsonPropertySignature(): OptionalKind<PropertySignatureStructure>;
+    get snippetDeclarations(): readonly string[];
+    private get declarationComment();
     private get pathExpression();
     classConstructorStatements({ variables, }: Parameters<Property<Type>["classConstructorStatements"]>[0]): readonly string[];
+    fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<Type>["fromRdfStatements"]>[0]): readonly string[];
     hashStatements(parameters: Parameters<Property<Type>["hashStatements"]>[0]): readonly string[];
-    sparqlGraphPatternExpression(): Maybe<string>;
+    interfaceConstructorStatements({ variables, }: Parameters<Property<Type>["interfaceConstructorStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: Parameters<Property<Type>["jsonUiSchemaElement"]>[0]): Maybe<string>;
+    jsonZodSchema(parameters: Parameters<Property<Type>["jsonZodSchema"]>[0]): ReturnType<Property<Type>["jsonZodSchema"]>;
+    sparqlConstructTemplateTriples({ variables, }: Parameters<Property<Type>["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns({ variables, }: Parameters<Property<Type>["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonObjectMember(parameters: Parameters<Property<Type>["toJsonObjectMember"]>[0]): string;
     toRdfStatements({ variables, }: Parameters<Property<Type>["toRdfStatements"]>[0]): readonly string[];
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map