@shaclmate/compiler 2.0.22 → 2.0.24

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

@@ -1,94 +1,33 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
+import { logger } from "../../../logger.js";
 import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    abstract;
-    equalsFunction = "booleanEquals";
-    mutable = false;
-    classDeclarationVisibility;
+    getAccessorScope;
     identifierMintingStrategy;
+    identifierPrefixPropertyName;
     override;
-    constructor({ abstract, classDeclarationVisibility, identifierMintingStrategy, override, ...superParameters }) {
+    propertyDeclarationVisibility;
+    typeAlias;
+    abstract;
+    equalsFunction = Maybe.of(`${syntheticNamePrefix}booleanEquals`);
+    mutable = false;
+    recursive = false;
+    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
         this.abstract = abstract;
-        this.classDeclarationVisibility = classDeclarationVisibility;
+        this.getAccessorScope = getAccessorScope;
+        this.propertyDeclarationVisibility = propertyDeclarationVisibility;
         this.identifierMintingStrategy = identifierMintingStrategy;
+        this.identifierPrefixPropertyName = identifierPrefixPropertyName;
         this.override = override;
-    }
-    get classGetAccessorDeclaration() {
-        if (this.abstract) {
-            return Maybe.empty();
-        }
-        if (this.identifierMintingStrategy.isNothing()) {
-            return Maybe.empty();
-        }
-        let memoizeMintedIdentifier;
-        let mintIdentifier;
-        switch (this.identifierMintingStrategy.unsafeCoerce()) {
-            case "blankNode":
-                memoizeMintedIdentifier = true;
-                mintIdentifier = "dataFactory.blankNode()";
-                break;
-            case "sha256":
-                // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
-                memoizeMintedIdentifier = !this.objectType.mutable();
-                mintIdentifier =
-                    "dataFactory.namedNode(`${this.identifierPrefix}${this.hashShaclProperties(sha256.create())}`)";
-                break;
-            case "uuidv4":
-                memoizeMintedIdentifier = true;
-                mintIdentifier =
-                    "dataFactory.namedNode(`${this.identifierPrefix}${uuid.v4()}`)";
-                break;
-        }
-        return Maybe.of({
-            leadingTrivia: this.override ? "override " : undefined,
-            name: this.name,
-            returnType: this.type.name,
-            statements: [
-                memoizeMintedIdentifier
-                    ? `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`
-                    : `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`,
-            ],
-        });
-    }
-    get classPropertyDeclaration() {
-        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,
-            });
-        }
-        // 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();
-        }
-        if (this.identifierMintingStrategy.isJust()) {
-            // 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`,
-            });
-        }
-        // Immutable, public identifier property, no getter
-        return Maybe.of({
-            isReadonly: true,
-            name: this.name,
-            type: this.type.name,
-        });
+        this.typeAlias = typeAlias;
     }
     get constructorParametersPropertySignature() {
         if (this.objectType.declarationType === "class" && this.abstract) {
@@ -100,9 +39,21 @@ export class IdentifierProperty extends Property {
                 typeNames.add(conversion.sourceTypeName);
             }
         }
+        let hasQuestionToken;
+        switch (this.objectType.declarationType) {
+            case "class":
+                hasQuestionToken = this.identifierMintingStrategy.isJust();
+                break;
+            case "interface": {
+                const identifierMintingStrategy = this.identifierMintingStrategy.extract();
+                hasQuestionToken =
+                    typeof identifierMintingStrategy !== "undefined" &&
+                        identifierMintingStrategy !== "sha256";
+                break;
+            }
+        }
         return Maybe.of({
-            hasQuestionToken: this.objectType.declarationType === "class" &&
-                this.identifierMintingStrategy.isJust(),
+            hasQuestionToken,
             isReadonly: true,
             name: this.name,
             type: [...typeNames].sort().join(" | "),
@@ -110,26 +61,68 @@ export class IdentifierProperty extends Property {
     }
     get declarationImports() {
         const imports = this.type.useImports().concat();
-        if (this.objectType.features.has("hash") &&
-            this.objectType.declarationType === "class") {
-            this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
-                switch (identifierMintingStrategy) {
-                    case "sha256":
-                        imports.push(Import.SHA256);
-                        break;
-                    case "uuidv4":
-                        imports.push(Import.UUID);
-                        break;
-                }
-            });
-        }
+        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+            switch (identifierMintingStrategy) {
+                case "sha256":
+                    imports.push(Import.SHA256);
+                    break;
+                case "uuidv4":
+                    imports.push(Import.UUID);
+                    break;
+            }
+        });
         return imports;
     }
-    get interfacePropertySignature() {
+    get getAccessorDeclaration() {
+        if (this.getAccessorScope.isNothing()) {
+            return Maybe.empty();
+        }
+        invariant(this.getAccessorScope.unsafeCoerce() === "public");
+        if (this.identifierMintingStrategy.isJust()) {
+            let memoizeMintedIdentifier;
+            let mintIdentifier;
+            switch (this.identifierMintingStrategy.unsafeCoerce()) {
+                case "blankNode":
+                    memoizeMintedIdentifier = true;
+                    mintIdentifier = "dataFactory.blankNode()";
+                    break;
+                case "sha256":
+                    // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
+                    memoizeMintedIdentifier = !this.objectType.mutable;
+                    mintIdentifier = `dataFactory.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${this.${syntheticNamePrefix}hashShaclProperties(sha256.create())}\`)`;
+                    break;
+                case "uuidv4":
+                    memoizeMintedIdentifier = true;
+                    mintIdentifier = `dataFactory.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${uuid.v4()}\`)`;
+                    break;
+            }
+            return Maybe.of({
+                leadingTrivia: this.override ? "override " : undefined,
+                name: this.name,
+                returnType: this.typeAlias,
+                statements: [
+                    memoizeMintedIdentifier
+                        ? `if (typeof this._${this.name} === "undefined") { this._${this.name} = ${mintIdentifier}; } return this._${this.name};`
+                        : `return (typeof this._${this.name} !== "undefined") ? this._${this.name} : ${mintIdentifier}`,
+                ],
+            });
+        }
+        invariant(this.propertyDeclaration.isNothing());
         return Maybe.of({
-            isReadonly: true,
+            leadingTrivia: this.override ? "override " : undefined,
             name: this.name,
-            type: this.type.name,
+            returnType: this.typeAlias,
+            statements: [`return super.${this.name} as ${this.typeAlias}`],
+        });
+    }
+    get graphqlField() {
+        invariant(this.name.startsWith(syntheticNamePrefix));
+        return Maybe.of({
+            args: Maybe.empty(),
+            description: Maybe.empty(),
+            name: `_${this.name.substring(syntheticNamePrefix.length)}`,
+            resolve: `(source) => ${this.typeAlias}.toString(source.${this.name})`,
+            type: this.type.graphqlName.toString(),
         });
     }
     get jsonPropertySignature() {
@@ -139,38 +132,64 @@ export class IdentifierProperty extends Property {
             type: "string",
         });
     }
-    get snippetDeclarations() {
-        const snippetDeclarations = [];
-        if (this.objectType.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
-        }
-        return snippetDeclarations;
-    }
-    classConstructorStatements({ variables, }) {
-        if (this.abstract) {
-            return [];
-        }
-        if (this.classPropertyDeclaration.isNothing()) {
-            return [];
-        }
-        const classPropertyDeclaration = this.classPropertyDeclaration.unsafeCoerce();
+    constructorStatements({ variables, }) {
+        let lhs;
+        const statements = [];
         const typeConversions = this.type.conversions;
-        if (typeConversions.length === 1) {
-            return [
-                `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
-            ];
+        switch (this.objectType.declarationType) {
+            case "class": {
+                if (this.abstract) {
+                    return [];
+                }
+                if (this.propertyDeclaration.isNothing()) {
+                    return [];
+                }
+                const propertyDeclaration = this.propertyDeclaration.unsafeCoerce();
+                if (typeConversions.length === 1) {
+                    return [`this.${propertyDeclaration.name} = ${variables.parameter};`];
+                }
+                lhs = `this.${propertyDeclaration.name}`;
+                break;
+            }
+            case "interface":
+                if (typeConversions.length === 1) {
+                    return [`const ${this.name} = ${variables.parameter};`];
+                }
+                lhs = this.name;
+                statements.push(`let ${this.name}: ${this.typeAlias};`);
+                break;
         }
-        const statements = [];
-        for (const conversion of this.type.conversions) {
+        const conversionBranches = [];
+        for (const conversion of typeConversions) {
             invariant(conversion.sourceTypeName !== "undefined");
-            statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${classPropertyDeclaration.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
-        }
-        if (classPropertyDeclaration.name.startsWith("_")) {
-            statements.push(`if (typeof ${variables.parameter} === "undefined") { }`);
+            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
+        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+            switch (this.objectType.declarationType) {
+                case "class":
+                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
+                    break;
+                case "interface": {
+                    let mintIdentifier;
+                    switch (identifierMintingStrategy) {
+                        case "blankNode":
+                            mintIdentifier = "dataFactory.blankNode()";
+                            break;
+                        case "sha256":
+                            logger.warn("minting %s identifiers with %s is unsupported", this.objectType.declarationType, identifierMintingStrategy);
+                            return;
+                        case "uuidv4":
+                            mintIdentifier = `dataFactory.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.objectType.discriminatorValue}:"}\${uuid.v4()}\`)`;
+                            break;
+                    }
+                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { ${lhs} = ${mintIdentifier}; }`);
+                }
+            }
+        });
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        statements.push(`{ this.${classPropertyDeclaration.name} =( ${variables.parameter}) as never;\n }`);
-        return [statements.join(" else ")];
+        conversionBranches.push(`{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
+        statements.push(conversionBranches.join(" else "));
+        return statements;
     }
     fromJsonStatements({ variables, }) {
         return [
@@ -182,30 +201,20 @@ export class IdentifierProperty extends Property {
             // Treat sh:in as a union of the IRIs
             // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
             return [
-                `let ${this.name}: ${this.type.name};`,
-                `switch (${variables.resource}.identifier.value) { ${this.type.in_.map((iri) => `case "${iri.value}": ${this.name} = ${this.rdfjsTermExpression(iri)}; break;`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${this.rdfjsTermExpression(rdf.subject)} })); }`,
+                `let ${this.name}: ${this.typeAlias};`,
+                `switch (${variables.resource}.identifier.value) { ${this.type.in_.map((iri) => `case "${iri.value}": ${this.name} = ${rdfjsTermExpression(iri)}; break;`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${rdfjsTermExpression(rdf.subject)} })); }`,
             ];
         }
-        return [`const ${this.name} = ${variables.resource}.identifier`];
+        const statements = [];
+        if (this.type.isNamedNodeKind) {
+            statements.push(`if (${variables.resource}.identifier.termType !== "NamedNode") { return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: ${variables.resource}.identifier, expectedValueType: ${JSON.stringify(this.type.name)}, focusResource: ${variables.resource}, predicate: ${rdfjsTermExpression(rdf.subject)} })); }`);
+        }
+        statements.push(`const ${this.name}: ${this.typeAlias} = ${variables.resource}.identifier;`);
+        return statements;
     }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value}.value);`];
     }
-    interfaceConstructorStatements({ variables, }) {
-        const typeConversions = this.type.conversions;
-        if (typeConversions.length === 1) {
-            return [`const ${this.name} = ${variables.parameter};`];
-        }
-        const statements = [`let ${this.name}: ${this.type.name};`];
-        const conversionBranches = [];
-        for (const conversion of this.type.conversions) {
-            conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${this.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
-        }
-        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        conversionBranches.push(`{ ${this.name} =( ${variables.parameter}) as never;\n }`);
-        statements.push(conversionBranches.join(" else "));
-        return statements;
-    }
     jsonUiSchemaElement({ variables, }) {
         return Maybe.of(`{ label: "Identifier", scope: \`\${${variables.scopePrefix}}/properties/${this.jsonPropertySignature.unsafeCoerce().name}\`, type: "Control" }`);
     }
@@ -224,6 +233,55 @@ export class IdentifierProperty extends Property {
             schema,
         });
     }
+    get propertyDeclaration() {
+        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.typeAlias,
+            });
+        }
+        // See note in TypeFactory re: the logic of whether to declare the identifier in the class or not.
+        if (!this.propertyDeclarationVisibility.isJust()) {
+            return Maybe.empty();
+        }
+        if (this.identifierMintingStrategy.isJust()) {
+            // Mutable _identifier property that will be lazily initialized by the getter to mint the identifier
+            return Maybe.of({
+                hasQuestionToken: true,
+                name: `_${this.name}`,
+                scope: this.propertyDeclarationVisibility
+                    .map(Property.visibilityToScope)
+                    .unsafeCoerce(),
+                type: `${this.typeAlias}`,
+            });
+        }
+        // Immutable, public identifier property, no getter
+        return Maybe.of({
+            isReadonly: true,
+            name: this.name,
+            type: this.typeAlias,
+        });
+    }
+    get propertySignature() {
+        return Maybe.of({
+            isReadonly: true,
+            name: this.name,
+            type: this.typeAlias,
+        });
+    }
+    snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.objectType.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.booleanEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples() {
         return [];
     }

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

@@ -0,0 +1,100 @@
+import { Maybe } from "purify-ts";
+import "ts-morph";
+import type { TsFeature } from "../../../enums/TsFeature.js";
+import { Import } from "../Import.js";
+import type { ObjectType } from "../ObjectType.js";
+import type { ObjectUnionType } from "../ObjectUnionType.js";
+import type { OptionType } from "../OptionType.js";
+import type { SetType } from "../SetType.js";
+import { Type as _Type } from "../Type.js";
+import { ShaclProperty } from "./ShaclProperty.js";
+export declare class LazyShaclProperty<LazyTypeT extends LazyShaclProperty.Type<ResolvedTypeT, StubTypeT>, ResolvedTypeT extends LazyShaclProperty.Type.ResolvedTypeConstraint, StubTypeT extends LazyShaclProperty.Type.StubTypeConstraint> extends ShaclProperty<LazyTypeT> {
+    readonly mutable = false;
+    readonly recursive = false;
+    get graphqlField(): ShaclProperty<LazyShaclProperty.Type<StubTypeT, ResolvedTypeT>>["graphqlField"];
+}
+export declare namespace LazyShaclProperty {
+    export abstract class Type<ResolvedTypeT extends Type.ResolvedTypeConstraint, StubTypeT extends Type.StubTypeConstraint> extends _Type {
+        readonly discriminatorProperty: _Type["discriminatorProperty"];
+        readonly mutable = false;
+        readonly typeof = "object";
+        abstract readonly graphqlArgs: Maybe<Record<string, {
+            type: string;
+        }>>;
+        protected readonly resolvedType: ResolvedTypeT;
+        protected readonly runtimeClass: {
+            readonly name: string;
+            readonly rawName: string;
+            readonly snippetDeclaration: string;
+            readonly stubPropertyName: string;
+        };
+        protected readonly stubType: StubTypeT;
+        constructor({ stubType, resolvedType, runtimeClass, }: {
+            stubType: StubTypeT;
+            resolvedType: ResolvedTypeT;
+            runtimeClass: Type<ResolvedTypeT, StubTypeT>["runtimeClass"];
+        });
+        get conversions(): readonly _Type.Conversion[];
+        get equalsFunction(): string;
+        get graphqlName(): _Type.GraphqlName;
+        hashStatements({ depth, variables, }: Parameters<_Type["hashStatements"]>[0]): readonly string[];
+        get jsonName(): _Type.JsonName;
+        jsonUiSchemaElement(parameters: Parameters<_Type["jsonUiSchemaElement"]>[0]): Maybe<string>;
+        jsonZodSchema(parameters: Parameters<_Type["jsonZodSchema"]>[0]): string;
+        get name(): string;
+        snippetDeclarations(parameters: Parameters<_Type["snippetDeclarations"]>[0]): readonly string[];
+        sparqlConstructTemplateTriples(parameters: Parameters<_Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+        sparqlWherePatterns(parameters: Parameters<_Type["sparqlWherePatterns"]>[0]): readonly string[];
+        toJsonExpression({ variables, }: Parameters<_Type["toJsonExpression"]>[0]): string;
+        toRdfExpression({ variables, }: Parameters<_Type["toRdfExpression"]>[0]): string;
+        useImports(parameters: {
+            features: Set<TsFeature>;
+        }): readonly Import[];
+    }
+    export namespace Type {
+        type ResolvedTypeConstraint = ObjectType | ObjectUnionType | OptionType<ObjectType | ObjectUnionType> | SetType<ObjectType | ObjectUnionType>;
+        type StubTypeConstraint = ResolvedTypeConstraint;
+    }
+    export class ObjectSetType<ResolvedTypeT extends SetType<ObjectType | ObjectUnionType>, StubTypeT extends SetType<ObjectType | ObjectUnionType>> extends Type<ResolvedTypeT, StubTypeT> {
+        constructor({ resolvedType, stubType, }: {
+            resolvedType: ResolvedTypeT;
+            stubType: StubTypeT;
+        });
+        get conversions(): readonly _Type.Conversion[];
+        fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
+        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+        get graphqlArgs(): Maybe<{
+            limit: {
+                type: string;
+            };
+            offset: {
+                type: string;
+            };
+        }>;
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
+    }
+    abstract class SingleObjectType<ResolvedTypeT extends Exclude<Type.ResolvedTypeConstraint, SetType<ObjectType | ObjectUnionType>>, StubTypeT extends Exclude<Type.StubTypeConstraint, SetType<ObjectType | ObjectUnionType>>> extends Type<ResolvedTypeT, StubTypeT> {
+        fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
+        get graphqlArgs(): Type<ResolvedTypeT, ObjectUnionType>["graphqlArgs"];
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
+    }
+    export class OptionalObjectType<ResolvedTypeT extends OptionType<ObjectType | ObjectUnionType>, StubTypeT extends OptionType<ObjectType | ObjectUnionType>> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
+        constructor({ resolvedType, stubType, }: {
+            resolvedType: ResolvedTypeT;
+            stubType: StubTypeT;
+        });
+        get conversions(): readonly _Type.Conversion[];
+        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+        graphqlResolveExpression(parameters: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
+    }
+    export class RequiredObjectType<ResolvedTypeT extends ObjectType | ObjectUnionType, StubTypeT extends ObjectType | ObjectUnionType> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
+        constructor({ resolvedType, stubType, }: {
+            resolvedType: ResolvedTypeT;
+            stubType: StubTypeT;
+        });
+        get conversions(): readonly _Type.Conversion[];
+        fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+    }
+    export {};
+}
+//# sourceMappingURL=LazyShaclProperty.d.ts.map