@shaclmate/compiler 4.0.8 → 4.0.9

package/dist/generators/ts/ObjectType.js

@@ -6,8 +6,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { camelCase } from "change-case";
 import { Maybe, NonEmptyList } from "purify-ts";
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
 import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
 import { identifierTypeDeclarations } from "./_ObjectType/identifierTypeDeclarations.js";
@@ -16,8 +16,11 @@ import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_c
 import { ObjectType_equalsFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_equalsFunctionOrMethodDeclaration.js";
 import { ObjectType_filterFunctionDeclaration } from "./_ObjectType/ObjectType_filterFunctionDeclaration.js";
 import { ObjectType_filterTypeDeclaration } from "./_ObjectType/ObjectType_filterTypeDeclaration.js";
-import { ObjectType_fromJsonFunctionDeclarations } from "./_ObjectType/ObjectType_fromJsonFunctionDeclarations.js";
-import { ObjectType_fromRdfFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfFunctionDeclaration.js";
+import { ObjectType_focusSparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_focusSparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectType_focusSparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_focusSparqlWherePatternsFunctionDeclaration.js";
+import { ObjectType_fromJsonFunctionDeclaration } from "./_ObjectType/ObjectType_fromJsonFunctionDeclaration.js";
+import { ObjectType_fromRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfResourceFunctionDeclaration.js";
+import { ObjectType_fromRdfResourceValuesFunctionDeclaration } from "./_ObjectType/ObjectType_fromRdfResourceValuesFunctionDeclaration.js";
 import { ObjectType_fromRdfTypeVariableStatement } from "./_ObjectType/ObjectType_fromRdfTypeVariableStatement.js";
 import { ObjectType_graphqlTypeVariableStatement } from "./_ObjectType/ObjectType_graphqlTypeVariableStatement.js";
 import { ObjectType_hashFunctionOrMethodDeclarations } from "./_ObjectType/ObjectType_hashFunctionOrMethodDeclarations.js";
@@ -28,39 +31,43 @@ import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_js
 import { ObjectType_jsonUiSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js";
 import { ObjectType_jsonZodSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonZodSchemaFunctionDeclaration.js";
 import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
-import { ObjectType_propertiesFromRdfFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromRdfFunctionDeclaration.js";
+import { ObjectType_parseJsonFunctionDeclaration } from "./_ObjectType/ObjectType_parseJsonFunctionDeclaration.js";
+import { ObjectType_propertiesFromJsonFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromJsonFunctionDeclaration.js";
+import { ObjectType_propertiesFromRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_propertiesFromRdfResourceFunctionDeclaration.js";
 import { ObjectType_schemaVariableStatement } from "./_ObjectType/ObjectType_schemaVariableStatement.js";
 import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
 import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { ObjectType_sparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructTriplesFunctionDeclaration.js";
-import { ObjectType_sparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlWherePatternsFunctionDeclarations.js";
 import { ObjectType_toJsonFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toJsonFunctionOrMethodDeclaration.js";
-import { ObjectType_toRdfFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toRdfFunctionOrMethodDeclaration.js";
+import { ObjectType_toRdfResourceFunctionOrMethodDeclaration } from "./_ObjectType/ObjectType_toRdfResourceFunctionOrMethodDeclaration.js";
+import { ObjectType_valueSparqlConstructTriplesFunctionDeclaration } from "./_ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js";
+import { ObjectType_valueSparqlWherePatternsFunctionDeclaration } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.js";
 import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
-import { TypeDiscriminantProperty as _TypeDiscriminantProperty } from "./_ObjectType/TypeDiscriminantProperty.js";
-import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
+import { AbstractType } from "./AbstractType.js";
 import { imports } from "./imports.js";
-import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, def, joinCode } from "./ts-poet-wrapper.js";
-export class ObjectType extends AbstractDeclaredType {
+export class ObjectType extends AbstractType {
     imports;
     toRdfTypes;
     abstract;
     declarationType;
     extern;
+    features;
     fromRdfType;
     graphqlArgs = Maybe.empty();
     identifierType;
     kind = "ObjectType";
+    name;
+    recursive;
     staticModuleName;
     synthetic;
     typeofs = NonEmptyList(["object"]);
-    constructor({ abstract, declarationType, extern, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
+    constructor({ abstract, declarationType, extern, features, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyIdentifierProperty, lazyParentObjectTypes, lazyProperties, name, recursive, staticModuleName, synthetic, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.abstract = abstract;
         this.declarationType = declarationType;
         this.extern = extern;
+        this.features = features;
         this.fromRdfType = fromRdfType;
         this.identifierType = identifierType;
         this.imports = imports;
@@ -68,21 +75,16 @@ export class ObjectType extends AbstractDeclaredType {
         this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
         this.lazyChildObjectTypes = lazyChildObjectTypes;
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
+        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
+        this.lazyIdentifierProperty = lazyIdentifierProperty;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
+        this.name = name;
+        this.recursive = recursive;
         this.staticModuleName = staticModuleName;
         this.synthetic = synthetic;
         this.toRdfTypes = toRdfTypes;
     }
-    get _discriminantProperty() {
-        const discriminantProperty = this.properties.find((property) => property instanceof ObjectType.TypeDiscriminantProperty);
-        invariant(discriminantProperty);
-        return {
-            name: discriminantProperty.name,
-            ownValues: discriminantProperty.type.ownValues,
-            descendantValues: discriminantProperty.type.descendantValues,
-        };
-    }
     get ancestorObjectTypes() {
         return this.lazyAncestorObjectTypes();
     }
@@ -108,20 +110,20 @@ export class ObjectType extends AbstractDeclaredType {
             const staticModuleDeclarations = [];
             switch (this.declarationType) {
                 case "class": {
-                    declarations.push(ObjectType_classDeclaration.bind(this)());
+                    declarations.push(ObjectType_classDeclaration.call(this));
                     break;
                 }
                 case "interface": {
-                    declarations.push(ObjectType_interfaceDeclaration.bind(this)());
-                    staticModuleDeclarations.push(...ObjectType_createFunctionDeclaration.bind(this)().toList(), ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...ObjectType_hashFunctionOrMethodDeclarations.bind(this)());
+                    declarations.push(ObjectType_interfaceDeclaration.call(this));
+                    staticModuleDeclarations.push(...ObjectType_createFunctionDeclaration.call(this).toList(), ...ObjectType_equalsFunctionOrMethodDeclaration.bind(this)().toList(), ...ObjectType_hashFunctionOrMethodDeclarations.call(this));
                     break;
                 }
             }
-            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.bind(this)().toList(), ...identifierTypeDeclarations.bind(this)(), ...ObjectType_jsonTypeAliasDeclaration.bind(this)().toList(), ObjectType_filterFunctionDeclaration.bind(this)(), ObjectType_filterTypeDeclaration.bind(this)(), ...ObjectType_fromJsonFunctionDeclarations.bind(this)(), ...ObjectType_fromRdfFunctionDeclaration.bind(this)().toList(), ...ObjectType_fromRdfTypeVariableStatement.bind(this)().toList(), ObjectType_isTypeFunctionDeclaration.bind(this)(), ...ObjectType_jsonSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_jsonUiSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_jsonZodSchemaFunctionDeclaration.bind(this)().toList(), ...ObjectType_propertiesFromRdfFunctionDeclaration.bind(this)().toList(), ObjectType_schemaVariableStatement.bind(this)(), ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
-                ? ObjectType_toJsonFunctionOrMethodDeclaration.bind(this)().toList()
+            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...ObjectType_jsonTypeAliasDeclaration.call(this).toList(), ObjectType_filterFunctionDeclaration.call(this), ObjectType_filterTypeDeclaration.call(this), ...ObjectType_focusSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_focusSparqlWherePatternsFunctionDeclaration.bind(this)().toList(), ...ObjectType_fromJsonFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfResourceFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfResourceValuesFunctionDeclaration.call(this).toList(), ...ObjectType_fromRdfTypeVariableStatement.call(this).toList(), ObjectType_isTypeFunctionDeclaration.call(this), ...ObjectType_jsonSchemaFunctionDeclaration.call(this).toList(), ...ObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(), ...ObjectType_jsonZodSchemaFunctionDeclaration.call(this).toList(), ...ObjectType_parseJsonFunctionDeclaration.call(this).toList(), ...ObjectType_propertiesFromJsonFunctionDeclaration.bind(this)().toList(), ...ObjectType_propertiesFromRdfResourceFunctionDeclaration.bind(this)().toList(), ObjectType_schemaVariableStatement.call(this), ...ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)().toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)().toList(), ...(this.declarationType === "interface"
+                ? ObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList()
                 : []), ...(this.declarationType === "interface"
-                ? ObjectType_toRdfFunctionOrMethodDeclaration.bind(this)().toList()
-                : []));
+                ? ObjectType_toRdfResourceFunctionOrMethodDeclaration.call(this).toList()
+                : []), ...ObjectType_valueSparqlConstructTriplesFunctionDeclaration.bind(this)().toList(), ...ObjectType_valueSparqlWherePatternsFunctionDeclaration.bind(this)().toList());
             if (staticModuleDeclarations.length > 0) {
                 declarations.push(code `\
 export namespace ${def(this.staticModuleName)} {
@@ -129,7 +131,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
 }`);
             }
         }
-        return joinCode(declarations, { on: "\n\n" });
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
     get descendantFromRdfTypeVariables() {
         return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
@@ -141,7 +143,11 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.lazyDescendantObjectTypes();
     }
     get discriminantProperty() {
-        return Maybe.of(this._discriminantProperty);
+        return Maybe.of({
+            name: this._discriminantProperty.name,
+            ownValues: this._discriminantProperty.type.ownValues,
+            descendantValues: this._discriminantProperty.type.descendantValues,
+        });
     }
     get discriminantValue() {
         return this.name;
@@ -166,12 +172,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.fromRdfType.map(() => code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfType`);
     }
     get graphqlType() {
-        return new AbstractDeclaredType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
+        return new AbstractType.GraphqlType(code `${this.staticModuleName}.${syntheticNamePrefix}GraphQL`);
     }
     get identifierProperty() {
-        const identifierProperty = this.properties.find((property) => property.kind === "IdentifierProperty");
-        invariant(identifierProperty);
-        return identifierProperty;
+        return this.lazyIdentifierProperty(this);
     }
     get identifierTypeAlias() {
         return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
@@ -180,7 +184,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return this.properties.some((property) => property.mutable);
     }
     get objectSetMethodNames() {
-        return ObjectType_objectSetMethodNames.bind(this)();
+        return ObjectType_objectSetMethodNames.call(this);
     }
     get ownProperties() {
         if (this.parentObjectTypes.length === 0) {
@@ -213,11 +217,11 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     get schemaType() {
         return code `typeof ${this.schema}`;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `(({ filter, ignoreRdfType, valueVariable, variablePrefix }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix }))`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlConstructTriples`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `(({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })))`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}valueSparqlWherePatterns`;
     }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {
@@ -225,6 +229,9 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         }
         return code `${imports.Resource}${this.identifierType.kind === "IriType" ? code `<${imports.NamedNode}>` : ""}`;
     }
+    get _discriminantProperty() {
+        return this.lazyDiscriminantProperty(this);
+    }
     get thisVariable() {
         switch (this.declarationType) {
             case "class":
@@ -237,10 +244,11 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     }
     fromJsonExpression({ variables, }) {
         // Assumes the JSON object has been recursively validated already.
-        return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value}).unsafeCoerce()`;
+        return code `${this.staticModuleName}.${syntheticNamePrefix}fromJson(${variables.value})`;
     }
-    fromRdfExpression({ variables, }) {
-        return code `${variables.resourceValues}.chain(values => values.chainMap(value => value.toResource().chain(resource => ${this.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { context: ${variables.context}, ${variables.ignoreRdfType ? "ignoreRdfType: true, " : ""}objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages} }))))`;
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues, ...options } = variables;
+        return code `${this.staticModuleName}.${syntheticNamePrefix}fromRdfResourceValues(${resourceValues}, ${options})`;
     }
     graphqlResolveExpression({ variables, }) {
         return variables.value;
@@ -258,7 +266,7 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         }
     }
     jsonType() {
-        return new AbstractDeclaredType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
+        return new AbstractType.JsonType(code `${this.staticModuleName}.${syntheticNamePrefix}Json`);
     }
     jsonUiSchemaElement({ variables, }) {
         return Maybe.of(code `${this.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix: ${variables.scopePrefix} })`);
@@ -287,12 +295,12 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
                 return code `${this.staticModuleName}.${syntheticNamePrefix}toJson(${variables.value})`;
         }
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         switch (this.declarationType) {
             case "class":
-                return code `[${variables.value}.${syntheticNamePrefix}toRdf({ graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+                return code `[${variables.value}.${syntheticNamePrefix}toRdfResource({ graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
             case "interface":
-                return code `[${this.staticModuleName}.${syntheticNamePrefix}toRdf(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+                return code `[${this.staticModuleName}.${syntheticNamePrefix}toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
         }
     }
     ensureAtMostOneSuperObjectType() {
@@ -303,12 +311,11 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
     lazyAncestorObjectTypes;
     lazyChildObjectTypes;
     lazyDescendantObjectTypes;
+    lazyDiscriminantProperty;
+    lazyIdentifierProperty;
     lazyParentObjectTypes;
     lazyProperties;
 }
-__decorate([
-    Memoize()
-], ObjectType.prototype, "_discriminantProperty", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "ancestorObjectTypes", null);
@@ -380,13 +387,16 @@ __decorate([
 ], ObjectType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "sparqlConstructTriplesFunction", null);
+], ObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], ObjectType.prototype, "sparqlWherePatternsFunction", null);
+], ObjectType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "toRdfjsResourceType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "_discriminantProperty", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "thisVariable", null);
@@ -397,6 +407,6 @@ __decorate([
     ObjectType.IdentifierPrefixProperty = _IdentifierPrefixProperty;
     ObjectType.IdentifierProperty = _IdentifierProperty;
     ObjectType.ShaclProperty = _ShaclProperty;
-    ObjectType.TypeDiscriminantProperty = _TypeDiscriminantProperty;
+    ObjectType.DiscriminantProperty = _DiscriminantProperty;
 })(ObjectType || (ObjectType = {}));
 //# sourceMappingURL=ObjectType.js.map

package/dist/generators/ts/OptionType.d.ts

@@ -14,21 +14,21 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get mutable(): boolean;
     get name(): Code;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     protected get schemaObject(): {
         kind: Code;
         item: Code;
     };
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
     hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
     jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
     jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
     toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace OptionType {
     type ItemType = AbstractContainerType.ItemType;

package/dist/generators/ts/OptionType.js

@@ -70,11 +70,11 @@ export class OptionType extends AbstractContainerType {
     get schemaType() {
         return code `${snippets.MaybeSchema}<${this.itemType.schemaType}>`;
     }
-    get sparqlConstructTriplesFunction() {
-        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
     get schemaObject() {
         return {
@@ -92,9 +92,9 @@ export class OptionType extends AbstractContainerType {
             ? expression
             : code `${expression}.map(item => (${itemFromJsonExpression}))`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        return code `${this.itemType.fromRdfExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
+        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${imports.Maybe}.of(value)) : ${imports.Resource}.Values.fromValue<${imports.Maybe}<${this.itemType.name}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${imports.Maybe}.empty() }))`;
     }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
@@ -128,8 +128,8 @@ export class OptionType extends AbstractContainerType {
     toJsonExpression({ variables, }) {
         return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
     }
-    toRdfExpression({ variables, }) {
-        const itemTypeToRdfExpression = this.itemType.toRdfExpression({
+    toRdfResourceValuesExpression({ variables, }) {
+        const itemTypeToRdfExpression = this.itemType.toRdfResourceValuesExpression({
             variables: { ...variables, value: code `value` },
         });
         let toRdfExpression = code `${variables.value}.toList()`;
@@ -162,10 +162,10 @@ __decorate([
 ], OptionType.prototype, "schemaType", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "sparqlConstructTriplesFunction", null);
+], OptionType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], OptionType.prototype, "sparqlWherePatternsFunction", null);
+], OptionType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "jsonType", null);

package/dist/generators/ts/SetType.d.ts

@@ -3,11 +3,11 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "SetType";
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
-    fromRdfExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
+    fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
-    toRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;

package/dist/generators/ts/SetType.js

@@ -13,15 +13,17 @@ import { code, joinCode } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "SetType";
-    get sparqlConstructTriplesFunction() {
-        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
+    get valueSparqlConstructTriplesFunction() {
+        return code `${snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
-    get sparqlWherePatternsFunction() {
-        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
+    get valueSparqlWherePatternsFunction() {
+        return code `${snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
-    fromRdfExpression(parameters) {
+    fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
-        const chain = [this.itemType.fromRdfExpression(parameters)];
+        const chain = [
+            this.itemType.fromRdfResourceValuesExpression(parameters),
+        ];
         if (this.minCount === 0 || this._mutable) {
             chain.push(code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`);
         }
@@ -32,24 +34,24 @@ export class SetType extends AbstractCollectionType {
         return joinCode(chain, { on: "." });
     }
     jsonType() {
-        const name = code `readonly (${this.itemType.jsonType().name})[]`;
+        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;
         if (this.minCount === 0) {
             return new AbstractCollectionType.JsonType(name, { optional: true });
         }
         return new AbstractCollectionType.JsonType(name);
     }
-    toRdfExpression({ variables, }) {
-        return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfExpression({
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `${variables.value}.flatMap((item) => ${this.itemType.toRdfResourceValuesExpression({
             variables: { ...variables, value: code `item` },
         })})`;
     }
 }
 __decorate([
     Memoize()
-], SetType.prototype, "sparqlConstructTriplesFunction", null);
+], SetType.prototype, "valueSparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], SetType.prototype, "sparqlWherePatternsFunction", null);
+], SetType.prototype, "valueSparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "jsonType", null);

package/dist/generators/ts/StringType.d.ts

@@ -7,7 +7,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "StringType";
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"string">;
     get name(): string;
     protected get schemaObject(): {
@@ -17,7 +17,7 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     };
     hashStatements({ variables, }: Parameters<AbstractPrimitiveType<string>["hashStatements"]>[0]): readonly Code[];
     jsonZodSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonZodSchema"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
     protected fromRdfExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<string>["fromRdfExpressionChain"]>;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/dist/generators/ts/StringType.js

@@ -18,7 +18,7 @@ export class StringType extends AbstractPrimitiveType {
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLString}`);
     kind = "StringType";
     schemaType = code `${snippets.StringSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.stringSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.stringSparqlWherePatterns}`;
     typeofs = NonEmptyList(["string"]);
     get name() {
         if (this.primitiveIn.length > 0) {
@@ -47,7 +47,7 @@ export class StringType extends AbstractPrimitiveType {
                 return code `${imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
         }
     }
-    toRdfExpression({ variables, }) {
+    toRdfResourceValuesExpression({ variables, }) {
         return code `[${snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${rdfjsTermExpression(this.datatype)}` : ""})]`;
     }
     fromRdfExpressionChain({ variables, }) {

package/dist/generators/ts/TermType.d.ts

@@ -8,7 +8,7 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     readonly kind = "TermType";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly schemaType: Code;
-    readonly sparqlWherePatternsFunction: Code;
+    readonly valueSparqlWherePatternsFunction: Code;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });

package/dist/generators/ts/TermType.js

@@ -19,7 +19,7 @@ export class TermType extends AbstractTermType {
     kind = "TermType";
     nodeKinds;
     schemaType = code `${snippets.TermSchema}`;
-    sparqlWherePatternsFunction = code `${snippets.termSparqlWherePatterns}`;
+    valueSparqlWherePatternsFunction = code `${snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
         this.nodeKinds = nodeKinds;
@@ -63,7 +63,7 @@ export class TermType extends AbstractTermType {
                     valueToNodeKind = code `${imports.dataFactory}.namedNode(${variables.value}["@id"])`;
                     break;
                 case "Literal":
-                    valueToNodeKind = code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]) : undefined))`;
+                    valueToNodeKind = code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
                     break;
                 default:
                     throw new RangeError(nodeKind);

package/dist/generators/ts/TsGenerator.js

@@ -1,38 +1,46 @@
 import * as ast from "../../ast/index.js";
 import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
-// import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
-// import { objectSetDeclarations } from "./objectSetDeclarations.js";
 import { snippets } from "./snippets.js";
 import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
-// import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
     typeFactory = new TypeFactory();
     generate(ast_) {
-        const declarations = [];
+        let declarations = [];
+        for (const astNamedUnionType of ast_.namedUnionTypes) {
+            if (astNamedUnionType.isObjectUnionType()) {
+                continue;
+            }
+            declarations = declarations.concat(this.typeFactory.createType(astNamedUnionType).declaration.toList());
+        }
         const objectTypesToposorted = ast.ObjectType.toposort(ast_.objectTypes).map((astObjectType) => this.typeFactory.createObjectType(astObjectType));
-        const objectUnionTypesToposorted = ast_.objectUnionTypes.map((astObjectUnionType) => this.typeFactory.createObjectUnionType(astObjectUnionType));
+        const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
+            .filter((_) => _.isObjectUnionType())
+            .map((astObjectUnionType) => this.typeFactory.createNamedObjectUnionType(astObjectUnionType));
         for (const objectType of objectTypesToposorted) {
-            declarations.push(objectType.declaration);
+            declarations = declarations.concat(objectType.declaration.toList());
         }
-        for (const objectUnionType of objectUnionTypesToposorted) {
-            declarations.push(objectUnionType.declaration);
+        for (const namedObjectUnionType of namedObjectUnionTypesToposorted) {
+            declarations = declarations.concat(namedObjectUnionType.declaration.toList());
         }
         const objectTypesNameSorted = objectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        const objectUnionTypesNameSorted = objectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        const uberObjectUnionType = synthesizeUberObjectUnionType({
-            objectTypes: objectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
-        });
-        declarations.push(uberObjectUnionType.declaration);
+        const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
+        if (objectTypesToposorted.length > 0) {
+            const uberObjectUnionType = synthesizeUberObjectUnionType({
+                objectTypes: objectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+            });
+            declarations = declarations.concat(uberObjectUnionType.declaration.toList());
+            namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+        }
         declarations.push(...objectSetDeclarations({
             objectTypes: objectTypesNameSorted,
-            objectUnionTypes: objectUnionTypesNameSorted.concat(uberObjectUnionType),
+            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }));
         declarations.push(...graphqlSchemaVariableStatement({
             objectTypes: objectTypesNameSorted,
-            objectUnionTypes: objectUnionTypesNameSorted.concat(uberObjectUnionType),
+            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }).toList());
         declarations.splice(0, 0, joinCode(Object.values(snippets)
             .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))

package/dist/generators/ts/Type.d.ts

@@ -1,3 +1,4 @@
+import type { AnonymousUnionType } from "./AnonymousUnionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
@@ -14,12 +15,12 @@ import type { LazyObjectSetType } from "./LazyObjectSetType.js";
 import type { LazyObjectType } from "./LazyObjectType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
+import type { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import type { NamedUnionType } from "./NamedUnionType.js";
 import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
 import type { StringType } from "./StringType.js";
 import type { TermType } from "./TermType.js";
-import type { UnionType } from "./UnionType.js";
-export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | ObjectType | ObjectUnionType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType;
+export type Type = AnonymousUnionType | BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType<ListType.ItemType> | LiteralType | NamedObjectUnionType | NamedUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType;
 //# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -1,17 +1,20 @@
 import type { Literal, NamedNode } from "@rdfjs/types";
-import type * as ast from "../../ast/index.js";
+import * as ast from "../../ast/index.js";
+import { AnonymousUnionType } from "./AnonymousUnionType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
+import { NamedUnionType } from "./NamedUnionType.js";
 import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
+    private cachedNamedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
-    private cachedObjectUnionTypesByShapeIdentifier;
+    createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
     createObjectType(astType: ast.ObjectType): ObjectType;
-    createObjectUnionType(astType: ast.ObjectUnionType): ObjectUnionType;
     createType(astType: ast.Type, parameters?: {
         defaultValue?: Literal | NamedNode;
     }): Type;
+    createUnionType(astType: ast.UnionType): AnonymousUnionType | NamedUnionType | NamedObjectUnionType;
     private createBlankNodeType;
     private createDefaultValueType;
     private createIdentifierType;
@@ -25,6 +28,5 @@ export declare class TypeFactory {
     private createOptionType;
     private createSetType;
     private createTermType;
-    private createUnionType;
 }
 //# sourceMappingURL=TypeFactory.d.ts.map