@shaclmate/compiler 2.0.14 → 2.0.16

package/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -1,7 +1,7 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Either, Left } from "purify-ts";
+import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import { TsFeature } from "../enums/TsFeature.js";
+import { TsFeature } from "../enums/index.js";
 import * as input from "../input/index.js";
 import { logger } from "../logger.js";
 import { pickLiteral } from "./pickLiteral.js";
@@ -106,12 +106,26 @@ export function transformNodeShapeToAstType(nodeShape) {
             tsFeatures: nodeShape.tsFeatures.orDefault(new Set(TsFeature.MEMBERS)),
         };
         this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, compositeType);
-        compositeType.memberTypes.push(...Either.rights(compositeTypeNodeShapes.map((nodeShape) => this.transformNodeShapeToAstType(nodeShape))).filter((nodeShapeAstType) => nodeShapeAstType.kind === "ObjectType"));
-        if (compositeType.memberTypes.length < compositeTypeNodeShapes.length) {
-            return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+        for (const memberNodeShape of compositeTypeNodeShapes) {
+            const memberAstTypeEither = this.transformNodeShapeToAstType(memberNodeShape);
+            if (memberAstTypeEither.isLeft()) {
+                return memberAstTypeEither;
+            }
+            const memberAstType = memberAstTypeEither.unsafeCoerce();
+            switch (memberAstType.kind) {
+                case "ObjectType":
+                    compositeType.memberTypes.push(memberAstType);
+                    break;
+                case "ObjectUnionType":
+                    compositeType.memberTypes.push(...memberAstType.memberTypes);
+                    break;
+                default:
+                    return Left(new Error(`${nodeShape} has one or more non-ObjectType node shapes in its logical constraint`));
+            }
         }
         return Either.of(compositeType);
     }
+    const identifierIn = nodeShape.constraints.in_.filter((term) => term.termType === "NamedNode");
     // Put a placeholder in the cache to deal with cyclic references
     // If this node shape's properties (directly or indirectly) refer to the node shape itself,
     // we'll return this placeholder.
@@ -126,9 +140,10 @@ export function transformNodeShapeToAstType(nodeShape) {
         fromRdfType: nodeShape.fromRdfType,
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         kind: "ObjectType",
-        mintingStrategy: nodeShape.mintingStrategy,
+        identifierIn,
+        identifierMintingStrategy: identifierIn.length === 0 ? nodeShape.mintingStrategy : Maybe.empty(),
+        identifierKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
         name: this.shapeAstName(nodeShape),
-        nodeKinds: nodeShape.nodeKinds,
         properties: [], // This is mutable, we'll populate it below.
         parentObjectTypes: [], // This is mutable, we'll populate it below
         toRdfTypes: nodeShape.toRdfTypes,

package/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -27,13 +27,13 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
                     nodeKinds.add(astType.identifierNodeKind);
                     break;
                 case "ObjectType":
-                    nodeKinds = astType.nodeKinds;
+                    nodeKinds = astType.identifierKinds;
                     break;
                 case "ObjectIntersectionType":
                 case "ObjectUnionType":
                     nodeKinds = new Set();
                     for (const memberType of astType.memberTypes) {
-                        for (const nodeKind of memberType.nodeKinds) {
+                        for (const nodeKind of memberType.identifierKinds) {
                             nodeKinds.add(nodeKind);
                         }
                     }
@@ -95,7 +95,9 @@ export function transformPropertyShapeToAstCompositeType(shape, inherited) {
     invariant(memberTypeEithers.length > 0);
     const memberTypes = Either.rights(memberTypeEithers);
     if (memberTypes.length !== memberTypeEithers.length) {
-        logger.warn("shape %s composition did not map all member types successfully", shape);
+        logger.warn("shape %s composition did not map all member types successfully: %s", shape, Either.lefts(memberTypeEithers)
+            .map((left) => left.message)
+            .join("; "));
         return memberTypeEithers[0];
     }
     invariant(memberTypes.length > 0);

package/ast/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { MintingStrategy } from "../enums/MintingStrategy.js";
+import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
 import type { Name } from "./Name.js";
 import type { Type } from "./Type.js";
 /**
@@ -33,7 +33,7 @@ export interface ListType {
     /**
      * Strategy for minting new list and sub-list identifiers.
      */
-    readonly mintingStrategy: Maybe<MintingStrategy>;
+    readonly mintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * The list should be mutable in generated code.
      */

package/ast/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
-import type { PredicatePath } from "@shaclmate/shacl-ast";
+import type { NodeKind, PredicatePath } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { MintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { IdentifierMintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
 import type { Name } from "./Name.js";
 import type { Type } from "./Type.js";
 export interface ObjectType {
@@ -52,6 +52,22 @@ export interface ObjectType {
      * class targets).
      */
     readonly fromRdfType: Maybe<NamedNode>;
+    /**
+     * Instances of this ObjectType must have explicit identifiers and the identifiers must be in this list of IRIs.
+     *
+     * Mutually exclusive with minting strategies
+     */
+    readonly identifierIn: readonly NamedNode[];
+    /**
+     * The RDF node kinds this ObjectType may be identified by.
+     *
+     * Used to associate instances with an RDF identifier.
+     */
+    readonly identifierKinds: Set<Exclude<NodeKind, "Literal">>;
+    /**
+     * Strategy for minting new object identifiers.
+     */
+    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * Type discriminator.
      */
@@ -60,20 +76,10 @@ export interface ObjectType {
      * Human-readable label from rdfs:label.
      */
     readonly label: Maybe<string>;
-    /**
-     * Strategy for minting new object identifiers.
-     */
-    readonly mintingStrategy: Maybe<MintingStrategy>;
     /**
      * Name of this type, usually derived from sh:name or shaclmate:name.
      */
     readonly name: Name;
-    /**
-     * The RDF node kinds this ObjectType may be identified by.
-     *
-     * Used to associate instances with an RDF identifier.
-     */
-    readonly nodeKinds: Set<"BlankNode" | "NamedNode">;
     /**
      * Immediate parent ObjectTypes of this Object types.
      *

package/enums/IdentifierMintingStrategy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
+ */
+export type IdentifierMintingStrategy = "sha256" | "uuidv4";
+//# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/enums/IdentifierMintingStrategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=IdentifierMintingStrategy.js.map

package/enums/index.d.ts

@@ -1,4 +1,4 @@
-export * from "./MintingStrategy.js";
+export * from "./IdentifierMintingStrategy.js";
 export * from "./PropertyVisibility.js";
 export * from "./TsFeature.js";
 export * from "./TsObjectDeclarationType.js";

package/enums/index.js

@@ -1,4 +1,4 @@
-export * from "./MintingStrategy.js";
+export * from "./IdentifierMintingStrategy.js";
 export * from "./PropertyVisibility.js";
 export * from "./TsFeature.js";
 export * from "./TsObjectDeclarationType.js";

package/generators/json/AstJsonGenerator.js

@@ -70,7 +70,11 @@ function typeToJson(type) {
                 parentObjectTypes: type.parentObjectTypes.length > 0
                     ? type.parentObjectTypes.map((type) => nameToJson(type.name))
                     : undefined,
-                nodeKinds: [...type.nodeKinds],
+                identifierIn: type.identifierIn.length > 0
+                    ? type.identifierIn.map(termToJson)
+                    : undefined,
+                identifierKinds: [...type.identifierKinds],
+                identifierMintingStrategy: type.identifierMintingStrategy.extract(),
                 toRdfTypes: type.toRdfTypes.length > 0
                     ? type.toRdfTypes.map(termToJson)
                     : undefined,

package/generators/ts/DateTimeType.d.ts

@@ -1,7 +1,8 @@
+import type { TsFeature } from "../../enums/index.js";
 import { PrimitiveType } from "./PrimitiveType.js";
 import type { Type } from "./Type.js";
 export declare class DateTimeType extends PrimitiveType<Date> {
-    readonly equalsFunction = "(left, right) => purifyHelpers.Equatable.EqualsResult.fromBooleanEqualsResult(left, right, left.getTime() === right.getTime())";
+    readonly equalsFunction = "dateEquals";
     readonly kind = "DateTimeType";
     readonly mutable = true;
     get conversions(): readonly Type.Conversion[];
@@ -11,6 +12,7 @@ export declare class DateTimeType extends PrimitiveType<Date> {
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
     propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<PrimitiveType<Date>["toRdfExpression"]>[0]): string;
 }

package/generators/ts/DateTimeType.js

@@ -1,9 +1,10 @@
 import { PrimitiveType } from "./PrimitiveType.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class DateTimeType extends PrimitiveType {
     constructor() {
         super(...arguments);
-        this.equalsFunction = "(left, right) => purifyHelpers.Equatable.EqualsResult.fromBooleanEqualsResult(left, right, left.getTime() === right.getTime())";
+        this.equalsFunction = "dateEquals";
         this.kind = "DateTimeType";
         this.mutable = true;
     }
@@ -46,6 +47,13 @@ export class DateTimeType extends PrimitiveType {
         }
         return expression;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.dateEquals);
+        }
+        return snippetDeclarations;
+    }
     toJsonExpression({ variables, }) {
         return `${variables.value}.toISOString()`;
     }

package/generators/ts/IdentifierType.d.ts

@@ -1,7 +1,9 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import { TermType } from "./TermType.js";
+import type { Type } from "./Type.js";
 export declare class IdentifierType extends TermType<BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
+    get conversions(): readonly Type.Conversion[];
     get isNamedNodeKind(): boolean;
     get jsonName(): string;
     get name(): string;

package/generators/ts/IdentifierType.js

@@ -11,6 +11,17 @@ export class IdentifierType extends TermType {
         super(...arguments);
         this.kind = "IdentifierType";
     }
+    get conversions() {
+        return super.conversions.concat([
+            {
+                conversionExpression: (value) => `${this.dataFactoryVariable}.namedNode(${value})`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: this.in_.length > 0
+                    ? this.in_.map((iri) => `"${iri.value}"`).join(" | ")
+                    : "string",
+            },
+        ]);
+    }
     get isNamedNodeKind() {
         return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");
     }

package/generators/ts/Import.d.ts

@@ -5,7 +5,6 @@ export type Import = ImportDeclarationStructure | string;
  */
 export declare namespace Import {
     const PURIFY: Import;
-    const PURIFY_HELPERS: Import;
     const RDF_LITERAL: Import;
     const RDFJS_RESOURCE: Import;
     const RDFJS_TYPES: Import;

package/generators/ts/Import.js

@@ -9,11 +9,6 @@ export var Import;
         moduleSpecifier: "purify-ts",
         namespaceImport: "purify",
     };
-    Import.PURIFY_HELPERS = {
-        kind: StructureKind.ImportDeclaration,
-        moduleSpecifier: "purify-ts-helpers",
-        namespaceImport: "purifyHelpers",
-    };
     Import.RDF_LITERAL = {
         kind: StructureKind.ImportDeclaration,
         moduleSpecifier: "rdf-literal",

package/generators/ts/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { MintingStrategy } from "../../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature } from "../../enums/index.js";
 import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class ListType extends Type {
@@ -13,7 +13,7 @@ export declare class ListType extends Type {
     constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
-        mintingStrategy: Maybe<MintingStrategy>;
+        mintingStrategy: Maybe<IdentifierMintingStrategy>;
         mutable: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof Type>[0]);
@@ -22,15 +22,16 @@ export declare class ListType extends Type {
     get equalsFunction(): string;
     get jsonName(): string;
     get name(): string;
-    get useImports(): readonly Import[];
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
     hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
     jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
     jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
     sparqlConstructTemplateTriples({ variables, context, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns({ variables, context, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(features: Set<TsFeature>): readonly Import[];
 }
 //# sourceMappingURL=ListType.d.ts.map

package/generators/ts/ListType.js

@@ -1,6 +1,7 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ListType extends Type {
@@ -26,7 +27,7 @@ export class ListType extends Type {
         return Maybe.empty();
     }
     get equalsFunction() {
-        return `((left, right) => purifyHelpers.Arrays.equals(left, right, ${this.itemType.equalsFunction}))`;
+        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
     get jsonName() {
         return `readonly (${this.itemType.jsonName})[]`;
@@ -34,13 +35,6 @@ export class ListType extends Type {
     get name() {
         return `${this.mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
-    get useImports() {
-        const imports = this.itemType.useImports.concat();
-        if (this.identifierNodeKind === "NamedNode") {
-            imports.push(Import.SHA256);
-        }
-        return imports;
-    }
     fromJsonExpression({ variables, }) {
         return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
     }
@@ -62,6 +56,13 @@ export class ListType extends Type {
     jsonZodSchema(parameters) {
         return `${this.itemType.jsonZodSchema(parameters)}.array()`;
     }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.arrayEquals);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples({ variables, context, }) {
         switch (context) {
             case "property":
@@ -123,6 +124,10 @@ export class ListType extends Type {
         }
     }
     sparqlWherePatterns({ variables, context, }) {
+        // Need to handle two cases:
+        // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
+        // (2) (?s, ?p, ?list) (?list, rdf:first, "element") (?list, rdf:rest, rdf:nil) etc. where list binds to the head of a list
+        // Case (2) is case (1) with OPTIONAL graph patterns to handle actual list elements.
         switch (context) {
             case "property":
                 return super.sparqlWherePatterns({ context, variables });
@@ -170,7 +175,7 @@ export class ListType extends Type {
                         subject: restNVariable,
                         predicate: this.rdfjsTermExpression(rdf.first),
                         object: itemNVariable,
-                    })}] }`, ...this.itemType.sparqlConstructTemplateTriples({
+                    })}] }`, ...this.itemType.sparqlWherePatterns({
                         context: "type",
                         variables: {
                             subject: itemNVariable,
@@ -185,7 +190,8 @@ export class ListType extends Type {
                     object: variable("RestNBasic"),
                 })}] }`);
                 patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
-                return patterns;
+                // Having an optional around everything handles the rdf:nil case
+                return [`{ type: "optional", patterns: [${patterns.join(", ")}] }`];
             }
         }
     }
@@ -235,12 +241,11 @@ export class ListType extends Type {
                 break;
             }
         }
-        return `${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        return `${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${objectInitializer({
-            identifier: subListIdentifier,
+      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${subListIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })});
       currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
@@ -259,15 +264,21 @@ export class ListType extends Type {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.${resourceSetMethodName}(${objectInitializer({
-            identifier: listIdentifier,
+    listResource: resourceSet.${resourceSetMethodName}(${listIdentifier}, ${objectInitializer({
             mutateGraph: variables.mutateGraph,
         })}),
   } as {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};
   },
-).listResource.identifier`;
+).listResource.identifier : dataFactory.namedNode("${rdf.nil.value}")`;
+    }
+    useImports(features) {
+        const imports = this.itemType.useImports(features).concat();
+        if (features.has("hash") && this.identifierNodeKind === "NamedNode") {
+            imports.push(Import.SHA256);
+        }
+        return imports;
     }
 }
 //# sourceMappingURL=ListType.js.map

package/generators/ts/ObjectType.d.ts

@@ -1,7 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
 import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
-import type { MintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
+import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../../enums/index.js";
 import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import { Import } from "./Import.js";
@@ -15,7 +15,7 @@ export declare class ObjectType extends DeclaredType {
     protected readonly extern: boolean;
     protected readonly fromRdfType: Maybe<NamedNode>;
     protected readonly label: Maybe<string>;
-    protected readonly mintingStrategy: Maybe<MintingStrategy>;
+    protected readonly mintingStrategy: Maybe<IdentifierMintingStrategy>;
     protected readonly toRdfTypes: readonly NamedNode[];
     private readonly imports;
     private readonly lazyAncestorObjectTypes;
@@ -34,7 +34,7 @@ export declare class ObjectType extends DeclaredType {
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
         lazyProperties: () => readonly ObjectType.Property[];
-        mintingStrategy: Maybe<MintingStrategy>;
+        mintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof DeclaredType>[0]);
     get _discriminatorProperty(): Type.DiscriminatorProperty;
@@ -56,7 +56,6 @@ export declare class ObjectType extends DeclaredType {
     get ownProperties(): readonly ObjectType.Property[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
-    get useImports(): readonly Import[];
     protected get thisVariable(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
@@ -74,10 +73,12 @@ export declare class ObjectType extends DeclaredType {
         readonly name: string;
         readonly named: boolean;
     };
+    snippetDeclarations(): readonly string[];
     sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
     sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(_features: Set<TsFeature>): readonly Import[];
     protected ensureAtMostOneSuperObjectType(): void;
 }
 export declare namespace ObjectType {

package/generators/ts/ObjectType.js

@@ -11,6 +11,7 @@ import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
 import { DeclaredType } from "./DeclaredType.js";
 import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import * as _ObjectType from "./_ObjectType/index.js";
 import { IdentifierProperty, TypeDiscriminatorProperty, } from "./_ObjectType/index.js";
 import { objectInitializer } from "./objectInitializer.js";
@@ -58,9 +59,6 @@ export class ObjectType extends DeclaredType {
             return [];
         }
         const imports = this.properties.flatMap((property) => property.declarationImports);
-        if (this.features.has("equals")) {
-            imports.push(Import.PURIFY_HELPERS);
-        }
         if (this.features.has("fromJson") || this.features.has("jsonSchema")) {
             imports.push(Import.ZOD);
         }
@@ -69,7 +67,6 @@ export class ObjectType extends DeclaredType {
         }
         if (this.features.has("fromRdf") || this.features.has("toRdf")) {
             imports.push(Import.PURIFY);
-            imports.push(Import.PURIFY_HELPERS);
             imports.push(Import.RDFJS_RESOURCE);
         }
         if (this.features.has("sparql")) {
@@ -87,6 +84,7 @@ export class ObjectType extends DeclaredType {
             ..._ObjectType.equalsFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.fromJsonFunctionDeclarations.bind(this)(),
             ..._ObjectType.fromRdfFunctionDeclarations.bind(this)(),
+            ..._ObjectType.fromRdfTypeVariableDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonSchemaFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonUiSchemaFunctionDeclaration.bind(this)().toList(),
             ..._ObjectType.jsonZodSchemaFunctionDeclaration.bind(this)().toList(),
@@ -117,7 +115,7 @@ export class ObjectType extends DeclaredType {
     get equalsFunction() {
         switch (this.declarationType) {
             case "class":
-                return "purifyHelpers.Equatable.equals";
+                return "((left, right) => left.equals(right))";
             case "interface":
                 return `${this.name}.equals`;
             default:
@@ -152,7 +150,7 @@ export class ObjectType extends DeclaredType {
         if (this.features.has("fromJson")) {
             return `Parameters<typeof ${this.name}.fromJson>[0]`;
         }
-        throw new RangeError("jsonName called when neither fromJson nor toJson features are enabled");
+        throw new RangeError(`${this.name}: jsonName called when neither fromJson nor toJson features are enabled`);
     }
     get jsonUiSchemaFunctionName() {
         if (this.ancestorObjectTypes.length > 0 ||
@@ -194,9 +192,6 @@ export class ObjectType extends DeclaredType {
         }
         return properties;
     }
-    get useImports() {
-        return this.imports;
-    }
     get thisVariable() {
         switch (this.declarationType) {
             case "class":
@@ -244,6 +239,20 @@ export class ObjectType extends DeclaredType {
             named: this.identifierType.isNamedNodeKind,
         };
     }
+    snippetDeclarations() {
+        const snippetDeclarations = [];
+        if (this.features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.EqualsResult);
+        }
+        if ((this.features.has("fromJson") || this.features.has("fromRdf")) &&
+            this.parentObjectTypes.length > 0) {
+            snippetDeclarations.push(SnippetDeclarations.UnwrapR);
+        }
+        for (const property of this.ownProperties) {
+            snippetDeclarations.push(...property.snippetDeclarations);
+        }
+        return snippetDeclarations;
+    }
     sparqlConstructTemplateTriples({ context, variables, }) {
         switch (context) {
             case "property":
@@ -288,6 +297,9 @@ export class ObjectType extends DeclaredType {
                 return `${this.name}.toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
         }
     }
+    useImports(_features) {
+        return this.imports;
+    }
     ensureAtMostOneSuperObjectType() {
         if (this.parentObjectTypes.length > 1) {
             throw new RangeError(`object type '${this.name}' has multiple super object types`);

package/generators/ts/ObjectUnionType.d.ts

@@ -34,7 +34,6 @@ export declare class ObjectUnionType extends DeclaredType {
     get equalsFunction(): string;
     get jsonName(): string;
     get mutable(): boolean;
-    get useImports(): readonly Import[];
     protected get thisVariable(): string;
     private get equalsFunctionDeclaration();
     private get fromJsonFunctionDeclaration();
@@ -53,6 +52,7 @@ export declare class ObjectUnionType extends DeclaredType {
     sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
     toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(): readonly Import[];
     private rdfjsResourceType;
 }
 //# sourceMappingURL=ObjectUnionType.d.ts.map