@shaclmate/compiler 3.0.3 → 4.0.0

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

@@ -0,0 +1,191 @@
+import type { Maybe } from "purify-ts";
+import type { PropertyVisibility } from "../../../enums/index.js";
+import type { ObjectType } from "../ObjectType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
+    protected readonly objectType: ObjectType;
+    /**
+     * Optional property to include in the parameters object of a class constructor.
+     */
+    abstract readonly constructorParametersSignature: Maybe<Code>;
+    /**
+     * Optional property declaration to include in a class or interface declaration of the object type.
+     */
+    abstract readonly declaration: Maybe<Code>;
+    /**
+     * Function declaration that takes two values of the property and compares them, returning an $EqualsResult.
+     */
+    abstract readonly equalsFunction: Maybe<Code>;
+    /**
+     * Optional property in the object type's filter.
+     */
+    abstract readonly filterProperty: Maybe<{
+        readonly name: string;
+        readonly type: Code;
+    }>;
+    /**
+     * Optional get accessor to include in a class declaration of the object type.
+     */
+    abstract readonly getAccessorDeclaration: Maybe<Code>;
+    /**
+     * GraphQL.js field definition.
+     */
+    abstract readonly graphqlField: Maybe<{
+        args: Maybe<Record<string, {
+            type: Code;
+        }>>;
+        description: Maybe<string>;
+        name: string;
+        resolve: Code;
+        type: Code;
+    }>;
+    /**
+     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
+     */
+    abstract readonly jsonSignature: Maybe<Code>;
+    /**
+     * zod Object key: schema pair on the property serialized by toJsonObjectMember.
+     */
+    abstract readonly jsonZodSchema: Maybe<{
+        readonly key: string;
+        readonly schema: Code;
+    }>;
+    /**
+     * Property type discriminator e.g., "ShaclProperty".
+     */
+    abstract readonly kind: string;
+    /**
+     * Is the property reassignable?
+     */
+    abstract readonly mutable: boolean;
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
+    readonly name: string;
+    /**
+     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
+     */
+    abstract readonly recursive: boolean;
+    /**
+     * Property type
+  .   */
+    readonly type: TypeT;
+    /**
+     * Property visibility: private, protected, public.
+     */
+    readonly visibility: PropertyVisibility;
+    constructor({ name, objectType, type, visibility, }: {
+        name: string;
+        objectType: ObjectType;
+        type: TypeT;
+        visibility: PropertyVisibility;
+    });
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    get schema(): Code;
+    protected get schemaObject(): {
+        kind: Code;
+        type: Code;
+    };
+    /**
+     * Statements to assign the parameter of described by constructorParametersSignature to a class or interface member.
+     */
+    abstract constructorStatements(parameters: {
+        variables: {
+            parameter: Code;
+            parameters: Code;
+        };
+    }): readonly Code[];
+    /**
+     * Statements to deserialize JSON for this property (as described by toJsonObjectMember) to a typed value of the property.
+     */
+    abstract fromJsonStatements(parameters: {
+        variables: {
+            jsonObject: Code;
+        };
+    }): readonly Code[];
+    /**
+     * Expression to deserialize this property on the given rdfjsResource.Resource to a Either<Error, this property type>.
+     */
+    abstract fromRdfExpression(parameters: {
+        variables: {
+            context: Code;
+            graph: Code;
+            objectSet: Code;
+            preferredLanguages: Code;
+            resource: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Statements to hash this property using a hasher instance.
+     */
+    abstract hashStatements(parameters: Parameters<Type["hashStatements"]>[0]): readonly Code[];
+    /**
+     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
+     */
+    abstract jsonUiSchemaElement(parameters: {
+        variables: {
+            scopePrefix: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * SPARQL.js CONSTRUCT template triples for this property.
+     *
+     * Parameters:
+     *   variables: runtime variables
+     *     - filter: an instance of the object's filterType or undefined
+     *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - variablePrefix: prefix to use for new SPARQL variables
+     *
+     * Returns a (runtime) array of sparqljs.Triple.
+     */
+    abstract sparqlConstructTriplesExpression(parameters: {
+        variables: {
+            filter: Code;
+            focusIdentifier: Code;
+            variablePrefix: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * SPARQL where patterns for this property.
+     *
+     * Parameters:
+     *   variables: (at runtime)
+     *     - filter: an instance of the object's filterType or undefined
+     *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
+     *     - preferredLanguages: array of preferred language code (strings)
+     *     - variablePrefix: prefix to use for new SPARQL variables
+     *
+     * Returns:
+     *   - condition: optional runtime condition to evaluate in an if statement before including the patterns
+     *   - patterns: runtime array of SparqlPattern's.
+     */
+    abstract sparqlWherePatternsExpression(parameters: {
+        variables: {
+            filter: Code;
+            focusIdentifier: Code;
+            preferredLanguages: Code;
+            variablePrefix: Code;
+        };
+    }): Maybe<{
+        condition?: Code;
+        patterns: Code;
+    }>;
+    /**
+     * Expression to serialize a property to a JSON object member.
+     */
+    abstract toJsonObjectMemberExpression(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Maybe<Code>;
+    /**
+     * Statements to serialize this property to an RDF resource.
+     */
+    abstract toRdfStatements(parameters: {
+        variables: Omit<Parameters<Type["toRdfExpression"]>[0]["variables"], "propertyPath">;
+    }): readonly Code[];
+}
+//# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -0,0 +1,49 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { invariant } from "ts-invariant";
+import { Memoize } from "typescript-memoize";
+import { removeUndefined } from "../removeUndefined.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export class AbstractProperty {
+    objectType;
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
+    name;
+    /**
+     * Property type
+  .   */
+    type;
+    /**
+     * Property visibility: private, protected, public.
+     */
+    visibility;
+    constructor({ name, objectType, type, visibility, }) {
+        this.name = name;
+        this.objectType = objectType;
+        this.type = type;
+        this.visibility = visibility;
+    }
+    /**
+     * TypeScript object describing this type, for runtime use.
+     */
+    get schema() {
+        return code `${removeUndefined(this.schemaObject)}`;
+    }
+    get schemaObject() {
+        invariant(this.kind.endsWith("Property"));
+        return {
+            kind: code `${literalOf(this.kind.substring(0, this.kind.length - "Property".length))} as const`,
+            // name: literalOf(this.name),
+            type: code `() => (${this.type.schema})`,
+        };
+    }
+}
+__decorate([
+    Memoize()
+], AbstractProperty.prototype, "schema", null);
+//# sourceMappingURL=AbstractProperty.js.map

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

@@ -1,35 +1,32 @@
 import { Maybe } from "purify-ts";
-import { type GetAccessorDeclarationStructure, type OptionalKind, type PropertyDeclarationStructure, type PropertySignatureStructure } from "ts-morph";
-import type { IdentifierType } from "../IdentifierType.js";
-import type { Import } from "../Import.js";
 import type { StringType } from "../StringType.js";
-import { Property } from "./Property.js";
-export declare class IdentifierPrefixProperty extends Property<StringType> {
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class IdentifierPrefixProperty extends AbstractProperty<StringType> {
     private readonly own;
-    readonly declarationImports: readonly Import[];
-    readonly graphqlField: Property<StringType>["graphqlField"];
-    readonly propertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
-    readonly jsonPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
+    readonly filterProperty: AbstractProperty<StringType>["filterProperty"];
+    readonly graphqlField: AbstractProperty<StringType>["graphqlField"];
+    readonly jsonSignature: Maybe<Code>;
+    readonly jsonZodSchema: AbstractProperty<StringType>["jsonZodSchema"];
+    readonly kind = "IdentifierPrefixProperty";
     readonly mutable = false;
     readonly recursive = false;
     constructor({ own, ...superParameters }: {
         own: boolean;
         type: StringType;
-    } & ConstructorParameters<typeof Property>[0]);
-    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get equalsFunction(): Maybe<string>;
-    constructorStatements({ variables, }: Parameters<Property<IdentifierType>["constructorStatements"]>[0]): readonly string[];
-    fromJsonStatements(): readonly string[];
-    fromRdfStatements(): readonly string[];
-    get getAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    hashStatements(): readonly string[];
-    jsonUiSchemaElement(): Maybe<string>;
-    jsonZodSchema(): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;
-    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
-    snippetDeclarations(): readonly string[];
-    sparqlConstructTemplateTriples(): readonly string[];
-    sparqlWherePatterns(): readonly string[];
-    toJsonObjectMember(): Maybe<string>;
-    toRdfStatements(): readonly string[];
+    } & ConstructorParameters<typeof AbstractProperty>[0]);
+    get constructorParametersSignature(): Maybe<Code>;
+    get declaration(): Maybe<Code>;
+    get equalsFunction(): Maybe<Code>;
+    get getAccessorDeclaration(): Maybe<Code>;
+    constructorStatements({ variables, }: Parameters<AbstractProperty<StringType>["constructorStatements"]>[0]): readonly Code[];
+    fromJsonStatements(): readonly Code[];
+    fromRdfExpression(): Maybe<Code>;
+    hashStatements(): readonly Code[];
+    jsonUiSchemaElement(): Maybe<Code>;
+    sparqlConstructTriplesExpression(): Maybe<Code>;
+    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<StringType>["sparqlWherePatternsExpression"]>;
+    toJsonObjectMemberExpression(): Maybe<Code>;
+    toRdfStatements(): readonly Code[];
 }
 //# sourceMappingURL=IdentifierPrefixProperty.d.ts.map

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

@@ -6,17 +6,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { Scope, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
-import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { Property } from "./Property.js";
-export class IdentifierPrefixProperty extends Property {
+import { code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export class IdentifierPrefixProperty extends AbstractProperty {
     own;
-    declarationImports = [];
+    filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
-    propertySignature = Maybe.empty();
-    jsonPropertySignature = Maybe.empty();
+    jsonSignature = Maybe.empty();
+    jsonZodSchema = Maybe.empty();
+    kind = "IdentifierPrefixProperty";
     mutable = false;
     recursive = false;
     constructor({ own, ...superParameters }) {
@@ -24,26 +25,34 @@ export class IdentifierPrefixProperty extends Property {
         invariant(this.visibility === "protected");
         this.own = own;
     }
-    get constructorParametersPropertySignature() {
-        return Maybe.of({
-            hasQuestionToken: true,
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
+    get constructorParametersSignature() {
+        return Maybe.of(code `readonly ${this.name}?: ${this.type.name};`);
+    }
+    get declaration() {
+        if (this.objectType.declarationType === "interface") {
+            return Maybe.empty();
+        }
+        if (!this.own) {
+            return Maybe.empty();
+        }
+        return Maybe.of(code `protected readonly _${this.name}?: ${this.type.name};`);
     }
     get equalsFunction() {
         return this.objectType.declarationType === "class"
-            ? Maybe.of(`${syntheticNamePrefix}strictEquals`)
+            ? Maybe.of(code `${snippets.strictEquals}`)
             : Maybe.empty();
     }
+    get getAccessorDeclaration() {
+        return Maybe.of(code `\
+protected ${!this.own ? "override " : ""} get ${this.name}(): ${this.type.name} {
+  return (this._${this.name} !== undefined) ? this._${this.name} : \`urn:shaclmate:\${this.${syntheticNamePrefix}type}:\`;
+}`);
+    }
     constructorStatements({ variables, }) {
         switch (this.objectType.declarationType) {
             case "class":
-                return this.propertyDeclaration
-                    .map((propertyDeclaration) => [
-                    `this.${propertyDeclaration.name} = ${variables.parameter};`,
-                ])
+                return this.declaration
+                    .map(() => [code `this._${this.name} = ${variables.parameter};`])
                     .orDefault([]);
             case "interface":
                 return [];
@@ -52,18 +61,8 @@ export class IdentifierPrefixProperty extends Property {
     fromJsonStatements() {
         return [];
     }
-    fromRdfStatements() {
-        return [];
-    }
-    get getAccessorDeclaration() {
-        return Maybe.of({
-            leadingTrivia: `protected ${!this.own ? "override " : ""}`,
-            name: this.name,
-            returnType: this.type.name,
-            statements: [
-                `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : \`urn:shaclmate:\${this.${syntheticNamePrefix}type}:\``,
-            ],
-        });
+    fromRdfExpression() {
+        return Maybe.empty();
     }
     hashStatements() {
         return [];
@@ -71,34 +70,13 @@ export class IdentifierPrefixProperty extends Property {
     jsonUiSchemaElement() {
         return Maybe.empty();
     }
-    jsonZodSchema() {
+    sparqlConstructTriplesExpression() {
         return Maybe.empty();
     }
-    get propertyDeclaration() {
-        return this.own
-            ? Maybe.of({
-                hasQuestionToken: true,
-                isReadonly: true,
-                name: `_${this.name}`,
-                scope: Scope.Protected,
-                type: this.type.name,
-            })
-            : Maybe.empty();
-    }
-    snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.strictEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlConstructTemplateTriples() {
-        return [];
-    }
-    sparqlWherePatterns() {
-        return [];
+    sparqlWherePatternsExpression() {
+        return Maybe.empty();
     }
-    toJsonObjectMember() {
+    toJsonObjectMemberExpression() {
         return Maybe.empty();
     }
     toRdfStatements() {

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

@@ -1,47 +1,49 @@
 import { Maybe } from "purify-ts";
-import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure, Scope } from "ts-morph";
-import type { IdentifierMintingStrategy, PropertyVisibility } from "../../../enums/index.js";
+import type { IdentifierMintingStrategy } from "../../../enums/index.js";
+import type { BlankNodeType } from "../BlankNodeType.js";
 import type { IdentifierType } from "../IdentifierType.js";
-import { Import } from "../Import.js";
-import { Property } from "./Property.js";
-export declare class IdentifierProperty extends Property<IdentifierType> {
-    private readonly getAccessorScope;
+import type { IriType } from "../IriType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
     private readonly identifierMintingStrategy;
     private readonly identifierPrefixPropertyName;
-    private readonly override;
-    private readonly propertyDeclarationVisibility;
     private readonly typeAlias;
-    readonly abstract: boolean;
-    readonly equalsFunction: Maybe<string>;
+    readonly kind = "IdentifierProperty";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }: {
-        abstract: boolean;
-        getAccessorScope: Maybe<Scope>;
-        propertyDeclarationVisibility: Maybe<PropertyVisibility>;
+    constructor({ identifierMintingStrategy, identifierPrefixPropertyName, typeAlias, ...superParameters }: {
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierPrefixPropertyName: string;
-        override: boolean;
-        type: IdentifierType;
-        typeAlias: string;
-    } & ConstructorParameters<typeof Property>[0]);
-    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    get declarationImports(): readonly Import[];
-    get getAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    get graphqlField(): Property<IdentifierType>["graphqlField"];
-    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    constructorStatements({ variables, }: Parameters<Property<IdentifierType>["constructorStatements"]>[0]): readonly string[];
-    fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
-    fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];
-    hashStatements({ variables, }: Parameters<Property<IdentifierType>["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement({ variables, }: Parameters<Property<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<string>;
-    jsonZodSchema({ variables, }: Parameters<Property<IdentifierType>["jsonZodSchema"]>[0]): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;
-    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
-    get propertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    snippetDeclarations(): readonly string[];
-    sparqlConstructTemplateTriples(): readonly string[];
-    sparqlWherePatterns(): readonly string[];
-    toJsonObjectMember({ variables, }: Parameters<Property<IdentifierType>["toJsonObjectMember"]>[0]): Maybe<string>;
-    toRdfStatements(): readonly string[];
+        type: BlankNodeType | IdentifierType | IriType;
+        typeAlias: Code;
+    } & ConstructorParameters<typeof AbstractProperty>[0]);
+    get constructorParametersSignature(): Maybe<Code>;
+    get declaration(): Maybe<Code>;
+    get equalsFunction(): Maybe<Code>;
+    get filterProperty(): Maybe<{
+        name: string;
+        type: Code;
+    }>;
+    get getAccessorDeclaration(): Maybe<Code>;
+    get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
+    get jsonSignature(): Maybe<Code>;
+    get jsonZodSchema(): AbstractProperty<IdentifierType>["jsonZodSchema"];
+    private get abstract();
+    private get declarationModifiers();
+    private get declarationName();
+    private get override();
+    constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
+    fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
+    fromRdfExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfExpression"]>[0]): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression(): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["sparqlWherePatternsExpression"]>[0]): Maybe<{
+        condition: Code;
+        patterns: Code;
+    }>;
+    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toRdfStatements(): readonly Code[];
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map