@shaclmate/compiler 2.0.13 → 2.0.14

package/generators/ts/ObjectType.d.ts

@@ -1,53 +1,72 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { MintingStrategy } from "../../ast";
+import { type ClassDeclarationStructure, type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
+import type { MintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
+import { DeclaredType } from "./DeclaredType.js";
 import type { IdentifierType } from "./IdentifierType.js";
-import { Type } from "./Type.js";
-import * as _ObjectType from "./_ObjectType";
-export declare class ObjectType extends Type {
+import { Import } from "./Import.js";
+import type { Type } from "./Type.js";
+import * as _ObjectType from "./_ObjectType/index.js";
+export declare class ObjectType extends DeclaredType {
     readonly abstract: boolean;
-    classDeclaration: typeof _ObjectType.classDeclaration;
-    equalsFunctionDeclaration: typeof _ObjectType.equalsFunctionDeclaration;
-    readonly export_: boolean;
-    fromRdfFunctionDeclaration: typeof _ObjectType.fromRdfFunctionDeclaration;
-    hashFunctionDeclaration: typeof _ObjectType.hashFunctionDeclaration;
-    readonly identifierType: IdentifierType;
-    interfaceDeclaration: typeof _ObjectType.interfaceDeclaration;
+    readonly declarationType: TsObjectDeclarationType;
     readonly kind = "ObjectType";
-    readonly mintingStrategy: Maybe<MintingStrategy>;
-    readonly name: string;
-    readonly rdfType: Maybe<NamedNode>;
-    sparqlGraphPatternsClassDeclaration: typeof _ObjectType.sparqlGraphPatternsClassDeclaration;
-    toRdfFunctionDeclaration: typeof _ObjectType.toRdfFunctionDeclaration;
+    protected readonly comment: Maybe<string>;
+    protected readonly extern: boolean;
+    protected readonly fromRdfType: Maybe<NamedNode>;
+    protected readonly label: Maybe<string>;
+    protected readonly mintingStrategy: Maybe<MintingStrategy>;
+    protected readonly toRdfTypes: readonly NamedNode[];
+    private readonly imports;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyDescendantObjectTypes;
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
-    constructor({ abstract, identifierType, export_, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, mintingStrategy, name, rdfType, ...superParameters }: {
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, mintingStrategy, toRdfTypes, ...superParameters }: {
         abstract: boolean;
-        export_: boolean;
-        identifierType: IdentifierType;
+        comment: Maybe<string>;
+        declarationType: TsObjectDeclarationType;
+        extern: boolean;
+        fromRdfType: Maybe<NamedNode>;
+        imports: readonly string[];
+        label: Maybe<string>;
         lazyAncestorObjectTypes: () => readonly ObjectType[];
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
         lazyProperties: () => readonly ObjectType.Property[];
         mintingStrategy: Maybe<MintingStrategy>;
-        name: string;
-        rdfType: Maybe<NamedNode>;
-    } & ConstructorParameters<typeof Type>[0]);
+        toRdfTypes: readonly NamedNode[];
+    } & ConstructorParameters<typeof DeclaredType>[0]);
+    get _discriminatorProperty(): Type.DiscriminatorProperty;
     get ancestorObjectTypes(): readonly ObjectType[];
     get conversions(): readonly Type.Conversion[];
+    get declarationImports(): readonly Import[];
+    get declarations(): (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
     get descendantObjectTypes(): readonly ObjectType[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get discriminatorValue(): string;
+    get equalsFunction(): string;
     get hashFunctionName(): string;
-    get importStatements(): readonly string[];
+    get identifierProperty(): ObjectType.IdentifierProperty;
+    get identifierType(): IdentifierType;
+    get jsonName(): string;
+    get jsonUiSchemaFunctionName(): string;
+    get jsonZodSchemaFunctionName(): string;
+    get mutable(): boolean;
+    get ownProperties(): readonly ObjectType.Property[];
     get parentObjectTypes(): readonly ObjectType[];
     get properties(): readonly ObjectType.Property[];
-    chainSparqlGraphPatternExpression({ variables, }: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): Maybe<Type.SparqlGraphPatternsExpression>;
-    equalsFunction(): string;
+    get useImports(): readonly Import[];
+    protected get thisVariable(): string;
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
     hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement({ variables, }: {
+        variables: {
+            scopePrefix: string;
+        };
+    }): Maybe<string>;
+    jsonZodSchema(_parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
     rdfjsResourceType(options?: {
         mutable?: boolean;
     }): {
@@ -55,6 +74,9 @@ export declare class ObjectType extends Type {
         readonly name: string;
         readonly named: boolean;
     };
+    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;
     protected ensureAtMostOneSuperObjectType(): void;
 }

package/generators/ts/ObjectType.js

@@ -4,33 +4,42 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { camelCase } from "change-case";
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { StructureKind, } from "ts-morph";
 import { Memoize } from "typescript-memoize";
-import { MintingStrategy } from "../../ast";
-import { Type } from "./Type.js";
-import * as _ObjectType from "./_ObjectType";
-export class ObjectType extends Type {
-    constructor({ abstract, identifierType, export_, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, mintingStrategy, name, rdfType, ...superParameters }) {
+import { DeclaredType } from "./DeclaredType.js";
+import { Import } from "./Import.js";
+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 }) {
         super(superParameters);
-        this.classDeclaration = _ObjectType.classDeclaration;
-        this.equalsFunctionDeclaration = _ObjectType.equalsFunctionDeclaration;
-        this.fromRdfFunctionDeclaration = _ObjectType.fromRdfFunctionDeclaration;
-        this.hashFunctionDeclaration = _ObjectType.hashFunctionDeclaration;
-        this.interfaceDeclaration = _ObjectType.interfaceDeclaration;
         this.kind = "ObjectType";
-        this.sparqlGraphPatternsClassDeclaration = _ObjectType.sparqlGraphPatternsClassDeclaration;
-        this.toRdfFunctionDeclaration = _ObjectType.toRdfFunctionDeclaration;
         this.abstract = abstract;
-        this.export_ = export_;
+        this.comment = comment;
+        this.declarationType = declarationType;
+        this.extern = extern;
+        this.fromRdfType = fromRdfType;
+        this.imports = imports;
+        this.label = label;
         // Lazily initialize some members in getters to avoid recursive construction
         this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
-        this.identifierType = identifierType;
         this.mintingStrategy = mintingStrategy;
-        this.rdfType = rdfType;
-        this.name = name;
+        this.toRdfTypes = toRdfTypes;
+    }
+    get _discriminatorProperty() {
+        const discriminatorProperty = this.properties.find((property) => property instanceof ObjectType.TypeDiscriminatorProperty);
+        invariant(discriminatorProperty);
+        return {
+            name: discriminatorProperty.name,
+            values: [this.discriminatorValue],
+        };
     }
     get ancestorObjectTypes() {
         return this.lazyAncestorObjectTypes();
@@ -44,39 +53,131 @@ export class ObjectType extends Type {
             },
         ];
     }
+    get declarationImports() {
+        if (this.extern) {
+            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);
+        }
+        if (this.features.has("jsonSchema")) {
+            imports.push(Import.ZOD_TO_JSON_SCHEMA);
+        }
+        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")) {
+            imports.push(Import.SPARQLJS);
+        }
+        return imports;
+    }
+    get declarations() {
+        const declarations = [
+            ..._ObjectType.classDeclaration.bind(this)().toList(),
+            ..._ObjectType.interfaceDeclaration.bind(this)().toList(),
+        ];
+        const moduleStatements = [
+            ..._ObjectType.createFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.equalsFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.fromJsonFunctionDeclarations.bind(this)(),
+            ..._ObjectType.fromRdfFunctionDeclarations.bind(this)(),
+            ..._ObjectType.jsonSchemaFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.jsonUiSchemaFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.jsonZodSchemaFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.hashFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.sparqlFunctionDeclarations.bind(this)(),
+            ..._ObjectType.toJsonFunctionDeclaration.bind(this)().toList(),
+            ..._ObjectType.toRdfFunctionDeclaration.bind(this)().toList(),
+        ];
+        if (moduleStatements.length > 0) {
+            declarations.push({
+                isExported: this.export,
+                kind: StructureKind.Module,
+                name: this.name,
+                statements: moduleStatements,
+            });
+        }
+        return declarations;
+    }
     get descendantObjectTypes() {
         return this.lazyDescendantObjectTypes();
     }
     get discriminatorProperty() {
-        return Maybe.of({
-            name: this.configuration.objectTypeDiscriminatorPropertyName,
-            type: "string",
-            values: [this.discriminatorValue],
-        });
+        return Maybe.of(this._discriminatorProperty);
     }
     get discriminatorValue() {
         return this.name;
     }
+    get equalsFunction() {
+        switch (this.declarationType) {
+            case "class":
+                return "purifyHelpers.Equatable.equals";
+            case "interface":
+                return `${this.name}.equals`;
+            default:
+                throw new RangeError(this.declarationType);
+        }
+    }
     get hashFunctionName() {
-        if (this.lazyDescendantObjectTypes().length > 0 ||
-            this.ancestorObjectTypes.length > 0) {
+        if (this.ancestorObjectTypes.length > 0 ||
+            this.descendantObjectTypes.length > 0)
             return `hash${this.name}`;
-        }
         return "hash";
     }
-    get importStatements() {
-        const importStatements = this.properties.flatMap((property) => property.importStatements);
-        this.mintingStrategy.ifJust((mintingStrategy) => {
-            switch (mintingStrategy) {
-                case MintingStrategy.SHA256:
-                    importStatements.push('import { sha256 } from "js-sha256";');
-                    break;
-                case MintingStrategy.UUIDv4:
-                    importStatements.push('import * as uuid from "uuid";');
-                    break;
+    get identifierProperty() {
+        const identifierProperty = this.properties.find((property) => property instanceof ObjectType.IdentifierProperty);
+        invariant(identifierProperty);
+        return identifierProperty;
+    }
+    get identifierType() {
+        return this.identifierProperty.type;
+    }
+    get jsonName() {
+        if (this.features.has("toJson")) {
+            switch (this.declarationType) {
+                case "class":
+                    return `ReturnType<${this.name}["toJson"]>`;
+                case "interface":
+                    return `ReturnType<typeof ${this.name}.toJson>`;
+                default:
+                    throw new RangeError(this.declarationType);
             }
-        });
-        return importStatements;
+        }
+        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");
+    }
+    get jsonUiSchemaFunctionName() {
+        if (this.ancestorObjectTypes.length > 0 ||
+            this.descendantObjectTypes.length > 0)
+            return `${camelCase(this.name)}JsonUiSchema`;
+        return "jsonUiSchema";
+    }
+    get jsonZodSchemaFunctionName() {
+        if (this.ancestorObjectTypes.length > 0 ||
+            this.descendantObjectTypes.length > 0)
+            return `${camelCase(this.name)}JsonZodSchema`;
+        return "jsonZodSchema";
+    }
+    get mutable() {
+        return this.properties.some((property) => property.mutable);
+    }
+    get ownProperties() {
+        if (this.parentObjectTypes.length === 0) {
+            // Consider that a root of the object type hierarchy "owns" the identifier and type discriminator properties
+            // for all of its subtypes in the hierarchy.
+            invariant(this.properties.length >= 2, this.name);
+            return this.properties;
+        }
+        return this.properties.filter((property) => !(property instanceof IdentifierProperty) &&
+            !(property instanceof TypeDiscriminatorProperty));
     }
     get parentObjectTypes() {
         return this.lazyParentObjectTypes();
@@ -93,24 +194,45 @@ export class ObjectType extends Type {
         }
         return properties;
     }
-    chainSparqlGraphPatternExpression({ variables, }) {
-        return Maybe.of(new Type.SparqlGraphPatternsExpression(`new ${this.name}.SparqlGraphPatterns(${variables.subject})`));
+    get useImports() {
+        return this.imports;
     }
-    equalsFunction() {
-        switch (this.configuration.objectTypeDeclarationType) {
+    get thisVariable() {
+        switch (this.declarationType) {
             case "class":
-                return "purifyHelpers.Equatable.equals";
+                return "this";
             case "interface":
-                return `${this.name}.equals`;
+                return `_${camelCase(this.name)}`;
+            default:
+                throw new RangeError(this.declarationType);
         }
     }
+    fromJsonExpression({ variables, }) {
+        // Assumes the JSON object has been recursively validated already.
+        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(resource))`;
+        // Ignore the rdf:type if the instance of this type is the object of another property.
+        // Instead, assume the property has the correct range.
+        // This also accommodates the case where the object of a property is a dangling identifier that's not the
+        // subject of any statements.
+        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: _resource }))`;
     }
     hashStatements({ variables, }) {
-        return [
-            `${this.name}.${this.hashFunctionName}(${variables.value}, ${variables.hasher});`,
-        ];
+        switch (this.declarationType) {
+            case "class":
+                return [`${variables.value}.hash(${variables.hasher});`];
+            case "interface":
+                return [
+                    `${this.name}.${this.hashFunctionName}(${variables.value}, ${variables.hasher});`,
+                ];
+        }
+    }
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(`${this.name}.${this.jsonUiSchemaFunctionName}({ scopePrefix: ${variables.scopePrefix} })`);
+    }
+    jsonZodSchema(_parameters) {
+        return `${this.name}.${this.jsonZodSchemaFunctionName}()`;
     }
     rdfjsResourceType(options) {
         if (this.parentObjectTypes.length > 0) {
@@ -122,12 +244,48 @@ export class ObjectType extends Type {
             named: this.identifierType.isNamedNodeKind,
         };
     }
+    sparqlConstructTemplateTriples({ context, variables, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlConstructTemplateTriples({ context, variables });
+            case "type":
+                return [
+                    `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
+                        ignoreRdfType: true, // Can ignore the rdf:type when the object is nested
+                        subject: variables.subject,
+                        variablePrefix: variables.variablePrefix,
+                    })})`,
+                ];
+        }
+    }
+    sparqlWherePatterns({ context, variables, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlWherePatterns({ context, variables });
+            case "type":
+                return [
+                    `...${this.name}.sparqlWherePatterns(${objectInitializer({
+                        ignoreRdfType: true, // Can ignore the rdf:type when the object is nested
+                        subject: variables.subject,
+                        variablePrefix: variables.variablePrefix,
+                    })})`,
+                ];
+        }
+    }
+    toJsonExpression({ variables, }) {
+        switch (this.declarationType) {
+            case "class":
+                return `${variables.value}.toJson()`;
+            case "interface":
+                return `${this.name}.toJson(${variables.value})`;
+        }
+    }
     toRdfExpression({ variables, }) {
-        switch (this.configuration.objectTypeDeclarationType) {
+        switch (this.declarationType) {
             case "class":
-                return `${variables.value}.toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier`;
+                return `${variables.value}.toRdf({ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
             case "interface":
-                return `${this.name}.toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }).identifier`;
+                return `${this.name}.toRdf(${variables.value}, { mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} })`;
         }
     }
     ensureAtMostOneSuperObjectType() {
@@ -145,6 +303,21 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "hashFunctionName", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "identifierProperty", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "identifierType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "jsonUiSchemaFunctionName", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "jsonZodSchemaFunctionName", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "ownProperties", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "parentObjectTypes", null);

package/generators/ts/ObjectUnionType.d.ts

@@ -0,0 +1,58 @@
+import { Maybe } from "purify-ts";
+import { type ModuleDeclarationStructure, type TypeAliasDeclarationStructure } from "ts-morph";
+import { DeclaredType } from "./DeclaredType.js";
+import type { Import } from "./Import.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { Type } from "./Type.js";
+/**
+ * A union of object types, generated as a type alias
+ *
+ *   type SomeUnion = Member1 | Member2 | ...
+ *
+ * with associated functions that switch on the type discriminator property and delegate to the appropriate
+ * member type code.
+ *
+ * It also generates SPARQL graph patterns that UNION the member object types.
+ */
+export declare class ObjectUnionType extends DeclaredType {
+    readonly kind = "ObjectUnionType";
+    private readonly _discriminatorProperty;
+    private readonly comment;
+    private readonly label;
+    private readonly memberTypes;
+    constructor({ comment, label, memberTypes, ...superParameters }: ConstructorParameters<typeof DeclaredType>[0] & {
+        comment: Maybe<string>;
+        export_: boolean;
+        label: Maybe<string>;
+        memberTypes: readonly ObjectType[];
+        name: string;
+    });
+    get conversions(): readonly Type.Conversion[];
+    get declarationImports(): readonly Import[];
+    get declarations(): (ModuleDeclarationStructure | TypeAliasDeclarationStructure)[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get equalsFunction(): string;
+    get jsonName(): string;
+    get mutable(): boolean;
+    get useImports(): readonly Import[];
+    protected get thisVariable(): string;
+    private get equalsFunctionDeclaration();
+    private get fromJsonFunctionDeclaration();
+    private get fromRdfFunctionDeclaration();
+    private get hashFunctionDeclaration();
+    private get jsonZodSchemaFunctionDeclaration();
+    private get sparqlFunctionDeclarations();
+    private get toJsonFunctionDeclaration();
+    private get toRdfFunctionDeclaration();
+    private get typeAliasDeclaration();
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema(): ReturnType<Type["jsonZodSchema"]>;
+    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;
+    private rdfjsResourceType;
+}
+//# sourceMappingURL=ObjectUnionType.d.ts.map