@shaclmate/compiler 2.0.15 → 2.0.17

package/{generators → dist/generators}/ts/ObjectType.js

@@ -16,9 +16,22 @@ import * as _ObjectType from "./_ObjectType/index.js";
 import { IdentifierProperty, TypeDiscriminatorProperty, } from "./_ObjectType/index.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ObjectType extends DeclaredType {
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, mintingStrategy, toRdfTypes, ...superParameters }) {
+    abstract;
+    declarationType;
+    kind = "ObjectType";
+    comment;
+    extern;
+    fromRdfType;
+    label;
+    identifierMintingStrategy;
+    toRdfTypes;
+    imports;
+    lazyAncestorObjectTypes;
+    lazyDescendantObjectTypes;
+    lazyParentObjectTypes;
+    lazyProperties;
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
         super(superParameters);
-        this.kind = "ObjectType";
         this.abstract = abstract;
         this.comment = comment;
         this.declarationType = declarationType;
@@ -31,7 +44,7 @@ export class ObjectType extends DeclaredType {
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
-        this.mintingStrategy = mintingStrategy;
+        this.identifierMintingStrategy = identifierMintingStrategy;
         this.toRdfTypes = toRdfTypes;
     }
     get _discriminatorProperty() {
@@ -84,6 +97,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(),

package/{generators → dist/generators}/ts/ObjectUnionType.js

@@ -26,9 +26,13 @@ import { tsComment } from "./tsComment.js";
  * It also generates SPARQL graph patterns that UNION the member object types.
  */
 export class ObjectUnionType extends DeclaredType {
+    kind = "ObjectUnionType";
+    _discriminatorProperty;
+    comment;
+    label;
+    memberTypes;
     constructor({ comment, label, memberTypes, ...superParameters }) {
         super(superParameters);
-        this.kind = "ObjectUnionType";
         this.comment = comment;
         this.label = label;
         invariant(memberTypes.length > 0);
@@ -170,14 +174,14 @@ return strictEquals(left.type, right.type).chain(() => {
             name: "fromRdf",
             parameters: [
                 {
-                    name: "parameters",
+                    name: "{ ignoreRdfType, resource, ...context }",
                     type: `{ [_index: string]: any; ignoreRdfType?: boolean; resource: ${this.rdfjsResourceType().name}; }`,
                 },
             ],
             returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
             statements: [
                 `return ${this.memberTypes.reduce((expression, memberType) => {
-                    const memberTypeExpression = `(${memberType.name}.fromRdf(parameters) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+                    const memberTypeExpression = `(${memberType.name}.fromRdf({ ...context, resource }) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
                     return expression.length > 0
                         ? `${expression}.altLazy(() => ${memberTypeExpression})`
                         : memberTypeExpression;
@@ -249,6 +253,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 isExported: true,
                 kind: StructureKind.Function,
                 name: "sparqlConstructTemplateTriples",
+                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
                         name: "parameters",
@@ -258,7 +263,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 returnType: "readonly sparqljs.Triple[]",
                 statements: [
                     `return [${this.memberTypes
-                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: parameters?.ignoreRdfType, subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
+                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
                         .join(", ")}];`,
                 ],
             },
@@ -266,6 +271,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 isExported: true,
                 kind: StructureKind.Function,
                 name: "sparqlWherePatterns",
+                // Accept ignoreRdfType in order to reuse code but don't pass it through, since deserialization may depend on it
                 parameters: [
                     {
                         name: "parameters",
@@ -276,7 +282,7 @@ return strictEquals(left.type, right.type).chain(() => {
                 statements: [
                     `return [{ patterns: [${this.memberTypes
                         .map((memberType) => objectInitializer({
-                        patterns: `${memberType.name}.sparqlWherePatterns({ ignoreRdfType: parameters?.ignoreRdfType, subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
+                        patterns: `${memberType.name}.sparqlWherePatterns({ subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
                         type: '"group"',
                     }))
                         .join(", ")}], type: "union" }];`,
@@ -363,7 +369,8 @@ return strictEquals(left.type, right.type).chain(() => {
         return `${this.name}.fromJson(${variables.value}).unsafeCoerce()`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, resource: _resource }))`;
+        // Don't ignoreRdfType, we may need it to distinguish the union members
+        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, languageIn: ${variables.languageIn}, resource: _resource }))`;
     }
     hashStatements({ variables, }) {
         switch (this.memberTypes[0].declarationType) {
@@ -383,7 +390,6 @@ return strictEquals(left.type, right.type).chain(() => {
             case "type":
                 return [
                     `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
-                        ignoreRdfType: true,
                         subject: variables.subject,
                         variablePrefix: variables.variablePrefix,
                     })})`,
@@ -397,7 +403,6 @@ return strictEquals(left.type, right.type).chain(() => {
             case "type":
                 return [
                     `...${this.name}.sparqlWherePatterns(${objectInitializer({
-                        ignoreRdfType: true,
                         subject: variables.subject,
                         variablePrefix: variables.variablePrefix,
                     })})`,

package/{generators → dist/generators}/ts/OptionType.js

@@ -9,9 +9,10 @@ import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 export class OptionType extends Type {
+    itemType;
+    kind = "OptionType";
     constructor({ itemType, ...superParameters }) {
         super(superParameters);
-        this.kind = "OptionType";
         this.itemType = itemType;
     }
     get conversions() {
@@ -80,7 +81,9 @@ export class OptionType extends Type {
         return `${this.itemType.jsonZodSchema(parameters)}.optional()`;
     }
     snippetDeclarations(features) {
-        const snippetDeclarations = [];
+        const snippetDeclarations = this.itemType
+            .snippetDeclarations(features)
+            .concat();
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.maybeEquals);
         }

package/{generators → dist/generators}/ts/PrimitiveType.js

@@ -2,9 +2,11 @@ import { Maybe } from "purify-ts";
 import { LiteralType } from "./LiteralType.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 export class PrimitiveType extends LiteralType {
+    equalsFunction = "strictEquals";
+    primitiveDefaultValue;
+    primitiveIn;
     constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "strictEquals";
         this.primitiveDefaultValue = primitiveDefaultValue;
         this.primitiveIn = primitiveIn;
     }

package/{generators → dist/generators}/ts/SetType.d.ts

@@ -5,8 +5,10 @@ export declare class SetType extends Type {
     readonly itemType: Type;
     readonly kind = "SetType";
     private readonly minCount;
-    constructor({ itemType, minCount, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+    private readonly _mutable;
+    constructor({ itemType, minCount, mutable, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
         itemType: Type;
+        mutable: boolean;
         minCount: number;
     });
     get conversions(): readonly Type.Conversion[];

package/{generators → dist/generators}/ts/SetType.js

@@ -10,12 +10,16 @@ import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class SetType extends Type {
-    constructor({ itemType, minCount, ...superParameters }) {
+    itemType;
+    kind = "SetType";
+    minCount;
+    _mutable;
+    constructor({ itemType, minCount, mutable, ...superParameters }) {
         super(superParameters);
-        this.kind = "SetType";
         this.itemType = itemType;
         this.minCount = minCount;
         invariant(this.minCount >= 0);
+        this._mutable = mutable;
     }
     get conversions() {
         const conversions = [];
@@ -44,15 +48,15 @@ export class SetType extends Type {
         return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
     get jsonName() {
-        if (this.minCount === 0) {
-            return `readonly (${this.itemType.jsonName})[]`;
-        }
-        return `purify.NonEmptyList<${this.itemType.jsonName}>`;
+        return `readonly (${this.itemType.jsonName})[]`;
     }
     get mutable() {
-        return this.itemType.mutable;
+        return this._mutable || this.itemType.mutable;
     }
     get name() {
+        if (this._mutable) {
+            return `(${this.itemType.name})[]`;
+        }
         if (this.minCount === 0) {
             return `readonly (${this.itemType.name})[]`;
         }
@@ -60,7 +64,7 @@ export class SetType extends Type {
     }
     fromJsonExpression({ variables, }) {
         let expression = variables.value;
-        if (this.minCount > 0) {
+        if (!this._mutable && this.minCount > 0) {
             expression = `purify.NonEmptyList.fromArray(${expression}).unsafeCoerce()`;
         }
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
@@ -74,7 +78,7 @@ export class SetType extends Type {
         const itemFromRdfExpression = this.itemType.fromRdfExpression({
             variables: { ...variables, resourceValues: "_item.toValues()" },
         });
-        if (this.minCount === 0) {
+        if (this._mutable || this.minCount === 0) {
             return `purify.Either.of([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())])`;
         }
         return `purify.NonEmptyList.fromArray([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())]).toEither(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is empty\``, predicate: variables.predicate })}))`;
@@ -103,7 +107,9 @@ export class SetType extends Type {
         return schema;
     }
     snippetDeclarations(features) {
-        const snippetDeclarations = [];
+        const snippetDeclarations = this.itemType
+            .snippetDeclarations(features)
+            .concat();
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }

package/{generators → dist/generators}/ts/StringType.js

@@ -8,10 +8,7 @@ import { Memoize } from "typescript-memoize";
 import { PrimitiveType } from "./PrimitiveType.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class StringType extends PrimitiveType {
-    constructor() {
-        super(...arguments);
-        this.kind = "StringType";
-    }
+    kind = "StringType";
     get conversions() {
         const conversions = [
             {

package/{generators → dist/generators}/ts/TermType.js

@@ -16,10 +16,14 @@ import { objectInitializer } from "./objectInitializer.js";
  * Abstract base class for IdentifierType and LiteralType.
  */
 export class TermType extends Type {
+    defaultValue;
+    equalsFunction = "booleanEquals";
+    hasValues;
+    in_;
+    mutable = false;
+    nodeKinds;
     constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "booleanEquals";
-        this.mutable = false;
         this.defaultValue = defaultValue;
         this.hasValues = hasValues;
         this.in_ = in_;
@@ -30,15 +34,15 @@ export class TermType extends Type {
         const conversions = [];
         if (this.nodeKinds.has("Literal")) {
             conversions.push({
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
                 sourceTypeName: "boolean",
             }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
                 sourceTypeName: "Date",
             }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
                 sourceTypeName: "number",
             }, {

package/{generators → dist/generators}/ts/Type.js

@@ -8,6 +8,7 @@ import { objectInitializer } from "./objectInitializer.js";
  * Subclasses are used for both property types (c.f., property* methods) and node/object types.
  */
 export class Type {
+    dataFactoryVariable;
     constructor({ dataFactoryVariable, }) {
         this.dataFactoryVariable = dataFactoryVariable;
     }

package/{generators → dist/generators}/ts/TypeFactory.js

@@ -6,6 +6,7 @@ import { fromRdf } from "rdf-literal";
 import { logger } from "../../logger.js";
 import { BooleanType } from "./BooleanType.js";
 import { DateTimeType } from "./DateTimeType.js";
+import { DateType } from "./DateType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
@@ -19,9 +20,10 @@ import { TermType } from "./TermType.js";
 import { UnionType } from "./UnionType.js";
 import { tsName } from "./tsName.js";
 export class TypeFactory {
+    cachedObjectTypePropertiesByIdentifier = new TermMap();
+    cachedObjectTypesByIdentifier = new TermMap();
+    dataFactoryVariable;
     constructor({ dataFactoryVariable }) {
-        this.cachedObjectTypePropertiesByIdentifier = new TermMap();
-        this.cachedObjectTypesByIdentifier = new TermMap();
         this.dataFactoryVariable = dataFactoryVariable;
     }
     createTypeFromAstType(astType) {
@@ -42,7 +44,7 @@ export class TypeFactory {
                     identifierNodeKind: astType.identifierNodeKind,
                     itemType: this.createTypeFromAstType(astType.itemType),
                     mutable: astType.mutable.orDefault(false),
-                    mintingStrategy: astType.mintingStrategy,
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
                     toRdfTypes: astType.toRdfTypes,
                 });
             }
@@ -76,8 +78,8 @@ export class TypeFactory {
                                 .filter((value) => typeof value === "boolean"),
                         });
                     }
-                    if (datatype.equals(xsd.dateTime)) {
-                        return new DateTimeType({
+                    if (datatype.equals(xsd.date) || datatype.equals(xsd.dateTime)) {
+                        return new (datatype.equals(xsd.date) ? DateType : DateTimeType)({
                             dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -186,6 +188,7 @@ export class TypeFactory {
                 return new SetType({
                     dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
+                    mutable: astType.mutable.orDefault(false),
                     minCount: astType.minCount,
                 });
             case "TermType":
@@ -214,8 +217,8 @@ export class TypeFactory {
             dataFactoryVariable: this.dataFactoryVariable,
             defaultValue: Maybe.empty(),
             hasValues: [],
-            in_: [],
-            nodeKinds: astType.nodeKinds,
+            in_: astType.identifierIn,
+            nodeKinds: astType.identifierKinds,
         });
         const objectType = new ObjectType({
             abstract: astType.abstract,
@@ -253,7 +256,7 @@ export class TypeFactory {
                     abstract: astType.abstract,
                     classDeclarationVisibility: identifierPropertyClassDeclarationVisibility,
                     dataFactoryVariable: this.dataFactoryVariable,
-                    mintingStrategy: astType.mintingStrategy,
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
                     name: astType.tsIdentifierPropertyName,
                     lazyObjectTypeMutable: () => properties.some((property) => property.mutable || property.type.mutable),
                     objectType: {
@@ -295,7 +298,7 @@ export class TypeFactory {
                 }
                 return properties.sort((left, right) => left.name.localeCompare(right.name));
             },
-            mintingStrategy: astType.mintingStrategy,
+            identifierMintingStrategy: astType.identifierMintingStrategy,
             name: tsName(astType.name),
             toRdfTypes: astType.toRdfTypes,
         });

package/{generators → dist/generators}/ts/UnionType.js

@@ -10,13 +10,15 @@ import { Memoize } from "typescript-memoize";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class UnionType extends Type {
+    kind = "UnionType";
+    memberTypes;
     constructor({ memberTypes, name, ...superParameters }) {
         super(superParameters);
-        this.kind = "UnionType";
         invariant(memberTypes.length >= 2);
         this.memberTypes = memberTypes;
         this._name = name;
     }
+    _name;
     get name() {
         if (typeof this._name === "undefined") {
             switch (this._discriminatorProperty.kind) {

package/{generators → dist/generators}/ts/_ObjectType/IdentifierProperty.d.ts

@@ -1,6 +1,6 @@
 import { Maybe } from "purify-ts";
 import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { MintingStrategy, PropertyVisibility } from "../../../enums/index.js";
+import type { IdentifierMintingStrategy, PropertyVisibility } from "../../../enums/index.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import { Import } from "../Import.js";
 import { Property } from "./Property.js";
@@ -9,14 +9,14 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     readonly equalsFunction = "booleanEquals";
     readonly mutable = false;
     private readonly classDeclarationVisibility;
+    private readonly identifierMintingStrategy;
     private readonly lazyObjectTypeMutable;
-    private readonly mintingStrategy;
     private readonly override;
-    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }: {
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }: {
         abstract: boolean;
         classDeclarationVisibility: Maybe<PropertyVisibility>;
         lazyObjectTypeMutable: () => boolean;
-        mintingStrategy: Maybe<MintingStrategy>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         override: boolean;
         type: IdentifierType;
     } & ConstructorParameters<typeof Property>[0]);
@@ -30,7 +30,7 @@ export declare class IdentifierProperty extends Property<IdentifierType> {
     classConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["classConstructorStatements"]>[0]): readonly string[];
     fromJsonStatements({ variables, }: Parameters<Property<IdentifierType>["fromJsonStatements"]>[0]): readonly string[];
     fromRdfStatements({ variables, }: Parameters<Property<IdentifierType>["fromRdfStatements"]>[0]): readonly string[];
-    hashStatements(): readonly string[];
+    hashStatements({ variables, }: Parameters<Property<IdentifierType>["hashStatements"]>[0]): readonly string[];
     interfaceConstructorStatements({ variables, }: Parameters<Property<IdentifierType>["interfaceConstructorStatements"]>[0]): readonly string[];
     jsonUiSchemaElement({ variables, }: Parameters<Property<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<string>;
     jsonZodSchema({ variables, }: Parameters<Property<IdentifierType>["jsonZodSchema"]>[0]): ReturnType<Property<IdentifierType>["jsonZodSchema"]>;

package/{generators → dist/generators}/ts/_ObjectType/IdentifierProperty.js

@@ -1,24 +1,30 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 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({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, mintingStrategy, override, ...superParameters }) {
+    abstract;
+    equalsFunction = "booleanEquals";
+    mutable = false;
+    classDeclarationVisibility;
+    identifierMintingStrategy;
+    lazyObjectTypeMutable;
+    override;
+    constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "booleanEquals";
-        this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
         this.classDeclarationVisibility = classDeclarationVisibility;
-        if (mintingStrategy.isJust()) {
-            this.mintingStrategy = mintingStrategy.unsafeCoerce();
+        if (identifierMintingStrategy.isJust()) {
+            this.identifierMintingStrategy = identifierMintingStrategy.unsafeCoerce();
         }
         else if (this.type.nodeKinds.has("BlankNode")) {
-            this.mintingStrategy = "blankNode";
+            this.identifierMintingStrategy = "blankNode";
         }
         else {
-            this.mintingStrategy = "none";
+            this.identifierMintingStrategy = "none";
         }
         this.lazyObjectTypeMutable = lazyObjectTypeMutable;
         this.override = override;
@@ -28,7 +34,7 @@ export class IdentifierProperty extends Property {
             return Maybe.empty();
         }
         let mintIdentifier;
-        switch (this.mintingStrategy) {
+        switch (this.identifierMintingStrategy) {
             case "blankNode":
                 mintIdentifier = "dataFactory.blankNode()";
                 break;
@@ -72,7 +78,7 @@ export class IdentifierProperty extends Property {
         if (!this.classDeclarationVisibility.isJust()) {
             return Maybe.empty();
         }
-        switch (this.mintingStrategy) {
+        switch (this.identifierMintingStrategy) {
             case "none":
                 // Immutable, public identifier property, no getter
                 return Maybe.of({
@@ -95,19 +101,25 @@ export class IdentifierProperty extends Property {
         if (this.objectType.declarationType === "class" && this.abstract) {
             return Maybe.empty();
         }
+        const typeNames = new Set(); // Remove duplicates with a set
+        for (const conversion of this.type.conversions) {
+            if (conversion.sourceTypeName !== "undefined") {
+                typeNames.add(conversion.sourceTypeName);
+            }
+        }
         return Maybe.of({
             hasQuestionToken: this.objectType.declarationType === "class" &&
-                this.mintingStrategy !== "none",
+                this.identifierMintingStrategy !== "none",
             isReadonly: true,
             name: this.name,
-            type: this.type.name,
+            type: [...typeNames].sort().join(" | "),
         });
     }
     get declarationImports() {
         const imports = this.type.useImports().concat();
         if (this.objectType.features.has("hash") &&
             this.objectType.declarationType === "class") {
-            switch (this.mintingStrategy) {
+            switch (this.identifierMintingStrategy) {
                 case "sha256":
                     imports.push(Import.SHA256);
                     break;
@@ -143,11 +155,27 @@ export class IdentifierProperty extends Property {
         if (this.abstract) {
             return [];
         }
-        return this.classPropertyDeclaration
-            .map((classPropertyDeclaration) => [
-            `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
-        ])
-            .orDefault([]);
+        if (this.classPropertyDeclaration.isNothing()) {
+            return [];
+        }
+        const classPropertyDeclaration = this.classPropertyDeclaration.unsafeCoerce();
+        const typeConversions = this.type.conversions;
+        if (typeConversions.length === 1) {
+            return [
+                `this.${classPropertyDeclaration.name} = ${variables.parameter};`,
+            ];
+        }
+        const statements = [];
+        for (const conversion of this.type.conversions) {
+            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") { }`);
+        }
+        // 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 ")];
     }
     fromJsonStatements({ variables, }) {
         return [
@@ -155,21 +183,63 @@ export class IdentifierProperty extends Property {
         ];
     }
     fromRdfStatements({ variables, }) {
+        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
+            // 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)} })); }`,
+            ];
+        }
         return [`const ${this.name} = ${variables.resource}.identifier`];
     }
-    hashStatements() {
-        return [];
+    hashStatements({ variables, }) {
+        if (this.abstract) {
+            // Identifier will only be hashed by a concrete class.
+            return [];
+        }
+        switch (this.identifierMintingStrategy) {
+            case "blankNode":
+            case "none":
+            case "uuidv4":
+                // The identifier minting won't call hash, so we should hash the identifier.
+                return [`${variables.hasher}.update(${variables.value}.value);`];
+            case "sha256":
+                // The identifier minting will call hash, so we can't hash the identifier.
+                return [];
+        }
     }
     interfaceConstructorStatements({ variables, }) {
-        return [`const ${this.name} = ${variables.parameter}`];
+        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.name}\`, type: "Control" }`);
     }
     jsonZodSchema({ variables, }) {
+        let schema;
+        if (this.type.in_.length > 0 && this.type.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            schema = `${variables.zod}.enum(${JSON.stringify(this.type.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            schema = `${variables.zod}.string().min(1)`;
+        }
         return {
             key: this.jsonPropertySignature.name,
-            schema: `${variables.zod}.string().min(1)`,
+            schema,
         };
     }
     sparqlConstructTemplateTriples() {

package/{generators → dist/generators}/ts/_ObjectType/Property.js

@@ -1,6 +1,20 @@
 import { Scope, } from "ts-morph";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
+    name;
+    /**
+     * Property type
+  .   */
+    type;
+    /**
+     * Property visibility: private, protected, public.
+     */
+    visibility;
+    dataFactoryVariable;
+    objectType;
     constructor({ dataFactoryVariable, name, objectType, type, visibility, }) {
         this.dataFactoryVariable = dataFactoryVariable;
         this.name = name;