@shaclmate/compiler 4.0.22 → 4.0.24

package/dist/generators/ts/TypeFactory.js

@@ -2,7 +2,7 @@ import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
 import { LiteralDecoder, literalDatatypeDefinitions } from "@rdfx/literal";
 import base62 from "@sindresorhus/base62";
-import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
+import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
@@ -112,16 +112,6 @@ export class TypeFactory {
                     visibility: "public",
                 });
             },
-            lazyIdentifierProperty: (namedObjectType) => new NamedObjectType.IdentifierProperty({
-                identifierMintingStrategy: astType.identifierMintingStrategy,
-                identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                logger: this.logger,
-                name: `${syntheticNamePrefix}identifier`,
-                namedObjectType,
-                type: identifierType,
-                typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
-                visibility: "public",
-            }),
             lazyParentObjectTypes: () => astType.parentObjectTypes.map((astType) => this.createNamedObjectType(astType)),
             lazyProperties: (namedObjectType) => {
                 const properties = astType.properties
@@ -142,28 +132,17 @@ export class TypeFactory {
                     namedObjectType._discriminantProperty.type.descendantValues.length > 0) {
                     properties.splice(0, 0, namedObjectType._discriminantProperty);
                 }
-                // Some ObjectTypes have an identifierPrefix property, depending on their identifier minting strategy.
-                if (namedObjectTypeNeedsIdentifierPrefixProperty(astType)) {
-                    properties.splice(0, 0, new NamedObjectType.IdentifierPrefixProperty({
+                if (namedObjectType.declarationType === "interface" ||
+                    namedObjectType.parentObjectTypes.length === 0) {
+                    properties.splice(0, 0, new NamedObjectType.IdentifierProperty({
                         logger: this.logger,
-                        name: `${syntheticNamePrefix}identifierPrefix`,
+                        name: `${syntheticNamePrefix}identifier`,
                         namedObjectType,
-                        own: !astType.ancestorObjectTypes.some(namedObjectTypeNeedsIdentifierPrefixProperty),
-                        type: new StringType({
-                            comment: astType.comment,
-                            datatype: xsd.string,
-                            hasValues: [],
-                            in_: [],
-                            label: astType.label,
-                            logger: this.logger,
-                            languageIn: [],
-                            primitiveIn: [],
-                        }),
-                        visibility: "protected",
+                        type: identifierType,
+                        typeAlias: code `${staticModuleName}.${syntheticNamePrefix}Identifier`,
+                        visibility: "public",
                     }));
                 }
-                // Every NamedObjectType has an identifier property. Some are abstract.
-                properties.splice(0, 0, namedObjectType.identifierProperty);
                 return properties;
             },
             logger: this.logger,
@@ -321,7 +300,6 @@ export class TypeFactory {
             logger: this.logger,
             minCount: 0,
             mutable: astType.mutable,
-            identifierMintingStrategy: astType.identifierMintingStrategy,
             toRdfTypes: astType.toRdfTypes,
         });
     }
@@ -455,6 +433,7 @@ export class TypeFactory {
         const property = new NamedObjectType.ShaclProperty({
             comment: astObjectTypeProperty.comment,
             description: astObjectTypeProperty.description,
+            display: astObjectTypeProperty.display,
             label: astObjectTypeProperty.label,
             logger: this.logger,
             mutable: astObjectTypeProperty.mutable,
@@ -501,22 +480,6 @@ export class TypeFactory {
         });
     }
 }
-function namedObjectTypeNeedsIdentifierPrefixProperty(namedObjectType) {
-    return namedObjectType.identifierMintingStrategy
-        .map((identifierMintingStrategy) => {
-        switch (identifierMintingStrategy) {
-            case "blankNode":
-                return false;
-            case "sha256":
-            case "uuidv4":
-                return true;
-            default:
-                identifierMintingStrategy;
-                throw new RangeError(identifierMintingStrategy);
-        }
-    })
-        .orDefault(false);
-}
 function tsName(name, options) {
     if (name[0] === "$") {
         return name;

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

@@ -12,13 +12,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     abstract readonly constructorParametersSignature: Maybe<Code>;
     /**
-     * Optional property declaration to include in a class or interface declaration of the object type.
+     * 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>;
+    abstract readonly declaration: Code;
     /**
      * Optional property in the object type's filter.
      */
@@ -26,10 +22,6 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         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.
      */
@@ -42,17 +34,17 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         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 jsonZchema: Maybe<{
+    abstract readonly jsonSchema: Maybe<{
         readonly key: string;
         readonly schema: Code;
     }>;
+    /**
+     * Signature of the property when serialized to JSON (the type of toJsonObjectMember).
+     */
+    abstract readonly jsonSignature: Maybe<Code>;
     /**
      * Property type discriminator e.g., "ShaclProperty".
      */
@@ -92,6 +84,14 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         kind: Code;
         type: Code;
     };
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }: {
+        variables: {
+            object: Code;
+        };
+    }): Code;
     /**
      * Statements to assign the parameter of described by constructorParametersSignature to a class or interface member.
      */
@@ -190,5 +190,13 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
     abstract toRdfRdfResourceValuesStatements(parameters: {
         variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
     }): readonly Code[];
+    /**
+     * Expression to serialize this property to a human-readable string (toString).
+     */
+    abstract toStringExpression(parameters: {
+        variables: {
+            value: Code;
+        };
+    }): Maybe<Code>;
 }
 //# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -44,6 +44,12 @@ export class AbstractProperty {
             type: code `() => (${this.type.schema})`,
         };
     }
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }) {
+        return code `${variables.object}.${this.name}`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.d.ts

@@ -3,9 +3,7 @@ import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
     readonly constructorParametersSignature: Maybe<Code>;
-    readonly equalsFunction: Maybe<Code>;
     readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
-    readonly getAccessorDeclaration: Maybe<Code>;
     readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
     readonly kind = "DiscriminantProperty";
     readonly mutable = false;
@@ -13,9 +11,9 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     constructor({ type, ...superParameters }: {
         type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
-    get declaration(): Maybe<Code>;
+    get declaration(): Code;
+    get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZchema(): AbstractProperty<DiscriminantProperty.Type>["jsonZchema"];
     private get abstract();
     private get initializer();
     private get override();
@@ -28,6 +26,7 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringExpression(): Maybe<Code>;
 }
 export declare namespace DiscriminantProperty {
     class Type {

package/dist/generators/ts/_NamedObjectType/DiscriminantProperty.js

@@ -9,14 +9,11 @@ import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { imports } from "../imports.js";
 import { removeUndefined } from "../removeUndefined.js";
-import { snippets } from "../snippets.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParametersSignature = Maybe.empty();
-    equalsFunction = Maybe.of(code `${snippets.strictEquals}`);
     filterProperty = Maybe.empty();
-    getAccessorDeclaration = Maybe.empty();
     graphqlField = Maybe.empty();
     kind = "DiscriminantProperty";
     mutable = false;
@@ -28,18 +25,18 @@ export class DiscriminantProperty extends AbstractProperty {
     get declaration() {
         switch (this.namedObjectType.declarationType) {
             case "class":
-                return Maybe.of(code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`);
+                return code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`;
             case "interface":
-                return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+                return code `readonly ${this.name}: ${this.type.name};`;
             default:
                 this.namedObjectType.declarationType;
                 throw new Error("should never reach this point");
         }
     }
-    get jsonSignature() {
-        return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
-    }
-    get jsonZchema() {
+    get jsonSchema() {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
@@ -47,6 +44,12 @@ export class DiscriminantProperty extends AbstractProperty {
                 : code `${imports.z}.literal(${literalOf(this.type.values[0])})`,
         });
     }
+    get jsonSignature() {
+        if (this.override) {
+            return Maybe.empty();
+        }
+        return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
+    }
     get abstract() {
         return this.namedObjectType.abstract;
     }
@@ -80,9 +83,15 @@ export class DiscriminantProperty extends AbstractProperty {
             : Maybe.empty();
     }
     hashStatements({ variables, }) {
+        if (this.override) {
+            return [];
+        }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
+        if (this.override) {
+            return Maybe.empty();
+        }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
         return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.initializer} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
@@ -93,18 +102,24 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     toJsonObjectMemberExpression({ variables, }) {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of(code `${this.name}: ${variables.value}`);
     }
     toRdfRdfResourceValuesStatements() {
         return [];
     }
+    toStringExpression() {
+        return Maybe.empty();
+    }
 }
 __decorate([
     Memoize()
-], DiscriminantProperty.prototype, "jsonSignature", null);
+], DiscriminantProperty.prototype, "jsonSchema", null);
 __decorate([
     Memoize()
-], DiscriminantProperty.prototype, "jsonZchema", null);
+], DiscriminantProperty.prototype, "jsonSignature", null);
 (function (DiscriminantProperty) {
     class Type {
         filterFunction = code `nonextant`;

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

@@ -1,38 +1,28 @@
 import { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../../enums/IdentifierMintingStrategy.js";
 import type { BlankNodeType } from "../BlankNodeType.js";
 import type { IdentifierType } from "../IdentifierType.js";
 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 typeAlias;
     readonly kind = "IdentifierProperty";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ identifierMintingStrategy, identifierPrefixPropertyName, typeAlias, ...superParameters }: {
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
-        identifierPrefixPropertyName: string;
+    constructor({ typeAlias, ...superParameters }: {
         type: BlankNodeType | IdentifierType | IriType;
         typeAlias: Code;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get constructorParametersSignature(): Maybe<Code>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Maybe<Code>;
+    get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
+    get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    get jsonZchema(): AbstractProperty<IdentifierType>["jsonZchema"];
-    private get abstract();
-    private get declarationModifiers();
-    private get declarationName();
-    private get override();
+    accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
@@ -45,5 +35,6 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     }>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map