@shaclmate/compiler 4.0.38 → 4.0.40

package/dist/generators/ts/ObjectType.js

@@ -0,0 +1,350 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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 { NodeKind } from "@shaclmate/shacl-ast";
+import { camelCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { Memoize } from "typescript-memoize";
+import { DiscriminantProperty as _DiscriminantProperty } from "./_ObjectType/DiscriminantProperty.js";
+import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
+import { identifierTypeDeclarations } from "./_ObjectType/identifierTypeDeclarations.js";
+import { ObjectType_createFunctionDeclaration } from "./_ObjectType/ObjectType_createFunctionDeclaration.js";
+import { ObjectType_equalsFunctionDeclaration } from "./_ObjectType/ObjectType_equalsFunctionDeclaration.js";
+import { ObjectType_filterFunctionDeclaration } from "./_ObjectType/ObjectType_filterFunctionDeclaration.js";
+import { ObjectType_filterTypeDeclaration } from "./_ObjectType/ObjectType_filterTypeDeclaration.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_hashFunctionDeclarations } from "./_ObjectType/ObjectType_hashFunctionDeclarations.js";
+import { ObjectType_interfaceDeclaration } from "./_ObjectType/ObjectType_interfaceDeclaration.js";
+import { ObjectType_isTypeFunctionDeclaration } from "./_ObjectType/ObjectType_isTypeFunctionDeclaration.js";
+import { ObjectType_jsonParseFunctionDeclaration } from "./_ObjectType/ObjectType_jsonParseFunctionDeclaration.js";
+import { ObjectType_jsonSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonSchemaFunctionDeclaration.js";
+import { ObjectType_jsonTypeAliasDeclaration } from "./_ObjectType/ObjectType_jsonTypeAliasDeclaration.js";
+import { ObjectType_jsonUiSchemaFunctionDeclaration } from "./_ObjectType/ObjectType_jsonUiSchemaFunctionDeclaration.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.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_toJsonFunctionDeclaration } from "./_ObjectType/ObjectType_toJsonFunctionDeclaration.js";
+import { ObjectType_toRdfResourceFunctionDeclaration } from "./_ObjectType/ObjectType_toRdfResourceFunctionDeclaration.js";
+import { ObjectType_toStringFunctionDeclarations } from "./_ObjectType/ObjectType_toStringFunctionDeclarations.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 { AbstractType } from "./AbstractType.js";
+import { code, def, joinCode } from "./ts-poet-wrapper.js";
+export class ObjectType extends AbstractType {
+    toRdfTypes;
+    conversionFunction = Maybe.empty();
+    extern;
+    fromRdfType;
+    graphqlArgs = Maybe.empty();
+    identifierType;
+    kind = "Object";
+    recursive;
+    referencesObjectType = true;
+    synthetic;
+    typeofs = ["object"];
+    validationFunction = Maybe.empty();
+    constructor({ extern, fromRdfType, identifierType, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyDiscriminantProperty, lazyParentObjectTypes, lazyProperties, recursive, synthetic, toRdfTypes, ...superParameters }) {
+        super(superParameters);
+        this.extern = extern;
+        this.fromRdfType = fromRdfType;
+        this.identifierType = identifierType;
+        // Lazily initialize some members in getters to avoid recursive construction
+        this.lazyAncestorObjectTypes = lazyAncestorObjectTypes;
+        this.lazyChildObjectTypes = lazyChildObjectTypes;
+        this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
+        this.lazyDiscriminantProperty = lazyDiscriminantProperty;
+        this.lazyParentObjectTypes = lazyParentObjectTypes;
+        this.lazyProperties = lazyProperties;
+        this.recursive = recursive;
+        this.synthetic = synthetic;
+        this.toRdfTypes = toRdfTypes;
+    }
+    get _discriminantProperty() {
+        return this.lazyDiscriminantProperty(this);
+    }
+    get ancestorObjectTypes() {
+        return this.lazyAncestorObjectTypes();
+    }
+    get childObjectTypes() {
+        return this.lazyChildObjectTypes();
+    }
+    get declaration() {
+        const alias = this.alias.extract();
+        if (!alias) {
+            return Maybe.empty();
+        }
+        const declarations = [];
+        if (!this.extern) {
+            const staticModuleDeclarations = [];
+            if (this.configuration.features.has("Object.type")) {
+                declarations.push(ObjectType_interfaceDeclaration.call(this));
+            }
+            staticModuleDeclarations.push(...ObjectType_createFunctionDeclaration.call(this).toList(), ...ObjectType_equalsFunctionDeclaration.call(this).toList(), ...ObjectType_hashFunctionDeclarations.call(this));
+            const jsonModuleDeclarations = [
+                ...ObjectType_jsonParseFunctionDeclaration.call(this).toList(),
+                ...ObjectType_jsonSchemaFunctionDeclaration.call(this).toList(),
+                ...ObjectType_jsonUiSchemaFunctionDeclaration.call(this).toList(),
+            ];
+            staticModuleDeclarations.push(...ObjectType_graphqlTypeVariableStatement.call(this).toList(), ...identifierTypeDeclarations.call(this), ...ObjectType_jsonTypeAliasDeclaration.call(this).toList(), ...(jsonModuleDeclarations.length > 0
+                ? [
+                    code `export namespace Json { ${joinCode(jsonModuleDeclarations, { on: "\n\n" })} }`,
+                ]
+                : []), ...ObjectType_filterFunctionDeclaration.call(this).toList(), ...ObjectType_filterTypeDeclaration.call(this).toList(), ...ObjectType_focusSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...ObjectType_focusSparqlWherePatternsFunctionDeclaration.call(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).toList(), ...ObjectType_schemaVariableStatement.call(this).toList(), ...ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                alias,
+                configuration: this.configuration,
+                filterType: this.filterType,
+                reusables: this.reusables,
+            }).toList(), ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                alias,
+                configuration: this.configuration,
+                filterType: this.filterType,
+                reusables: this.reusables,
+            }).toList(), ...ObjectType_toJsonFunctionDeclaration.call(this).toList(), ...ObjectType_toRdfResourceFunctionDeclaration.call(this).toList(), ...ObjectType_toStringFunctionDeclarations.call(this), ...ObjectType_valueSparqlConstructTriplesFunctionDeclaration.call(this).toList(), ...ObjectType_valueSparqlWherePatternsFunctionDeclaration.call(this).toList());
+            if (staticModuleDeclarations.length > 0) {
+                declarations.push(code `\
+export namespace ${def(alias)} {
+${joinCode(staticModuleDeclarations, { on: "\n\n" })}
+}`);
+            }
+        }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
+    }
+    get descendantFromRdfTypeVariables() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfTypeVariable.toList());
+    }
+    get descendantFromRdfTypes() {
+        return this.descendantObjectTypes.flatMap((descendantObjectType) => descendantObjectType.fromRdfType.toList());
+    }
+    get descendantObjectTypes() {
+        return this.lazyDescendantObjectTypes();
+    }
+    get discriminantProperty() {
+        return Maybe.of({
+            jsonName: this._discriminantProperty.jsonName,
+            name: this._discriminantProperty.name,
+            ownValues: this._discriminantProperty.type.ownValues,
+            descendantValues: this._discriminantProperty.type.descendantValues,
+        });
+    }
+    get discriminantValue() {
+        return this.alias.unsafeCoerce();
+    }
+    get equalsFunction() {
+        return code `${this.alias.unsafeCoerce()}.equals`;
+    }
+    get expression() {
+        return code `${this.alias.unsafeCoerce()}`;
+    }
+    get filterFunction() {
+        return code `${this.alias.unsafeCoerce()}.filter`;
+    }
+    get filterType() {
+        return code `${this.alias.unsafeCoerce()}.Filter`;
+    }
+    get fromRdfTypeVariable() {
+        return this.fromRdfType.map(() => code `${this.alias.unsafeCoerce()}.fromRdfType`);
+    }
+    get graphqlType() {
+        return new AbstractType.GraphqlType(code `${this.alias.unsafeCoerce()}.GraphQL`, this.reusables);
+    }
+    get hashFunction() {
+        return code `${this.alias.unsafeCoerce()}.hash`;
+    }
+    get identifierTypeAlias() {
+        return code `${this.alias.unsafeCoerce()}.Identifier`;
+    }
+    get mutable() {
+        return this.properties.some((property) => property.mutable);
+    }
+    get objectSetMethodNames() {
+        return ObjectType_objectSetMethodNames.call({
+            alias: this.alias.unsafeCoerce(),
+            configuration: this.configuration,
+        });
+    }
+    get parentObjectTypes() {
+        return this.lazyParentObjectTypes();
+    }
+    get properties() {
+        const properties = this.lazyProperties(this);
+        const propertyNames = new Set();
+        for (const property of properties) {
+            if (propertyNames.has(property.name)) {
+                throw new Error(`duplicate property '${property.name}'`);
+            }
+        }
+        return properties;
+    }
+    get schema() {
+        return code `${this.alias.unsafeCoerce()}.schema`;
+    }
+    get schemaType() {
+        return code `typeof ${this.schema}`;
+    }
+    get toRdfResourceValueTypes() {
+        return new Set([...this.identifierType.nodeKinds].map(NodeKind.toTermType));
+    }
+    get toRdfjsResourceType() {
+        if (this.parentObjectTypes.length > 0) {
+            return this.parentObjectTypes[0].toRdfjsResourceType;
+        }
+        return code `${this.reusables.imports.Resource}${this.identifierType.kind === "Iri" ? code `<${this.reusables.imports.NamedNode}>` : ""}`;
+    }
+    get valueSparqlConstructTriplesFunction() {
+        return code `${this.alias.unsafeCoerce()}.valueSparqlConstructTriples`;
+    }
+    get valueSparqlWherePatternsFunction() {
+        return code `${this.alias.unsafeCoerce()}.valueSparqlWherePatterns`;
+    }
+    get thisVariable() {
+        return code `_${camelCase(this.alias.unsafeCoerce())}`;
+    }
+    fromJsonExpression({ variables, }) {
+        // Assumes the JSON object has been recursively validated already.
+        return code `${this.alias.unsafeCoerce()}.fromJson(${variables.value})`;
+    }
+    fromRdfResourceValuesExpression({ variables, }) {
+        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
+        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
+        if (!this.configuration.features.has("ObjectSet")) {
+            delete fromRdfResourceValuesOptions["objectSet"];
+        }
+        return code `${this.alias.unsafeCoerce()}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+    jsonSchema({ context, }) {
+        let expression = code `${this.alias.unsafeCoerce()}.Json.schema()`;
+        if (context === "property" &&
+            this.properties.some((property) => property.recursive)) {
+            expression = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.alias.unsafeCoerce()}.Json> => ${expression})`;
+        }
+        return expression;
+    }
+    jsonType() {
+        return new AbstractType.JsonType(code `${this.alias.unsafeCoerce()}.Json`);
+    }
+    jsonUiSchemaElement({ variables, }) {
+        return Maybe.of(code `${this.alias.unsafeCoerce()}.Json.uiSchema({ scopePrefix: ${variables.scopePrefix} })`);
+    }
+    toJsonExpression({ variables, }) {
+        return code `${this.alias.unsafeCoerce()}.toJson(${variables.value})`;
+    }
+    toRdfResourceValuesExpression({ variables, }) {
+        return code `[${this.alias.unsafeCoerce()}.toRdfResource(${variables.value}, { graph: ${variables.graph}, resourceSet: ${variables.resourceSet} }).identifier]`;
+    }
+    toStringExpression({ variables, }) {
+        return code `${this.alias.unsafeCoerce()}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
+    }
+    lazyAncestorObjectTypes;
+    lazyChildObjectTypes;
+    lazyDescendantObjectTypes;
+    lazyDiscriminantProperty;
+    lazyParentObjectTypes;
+    lazyProperties;
+}
+__decorate([
+    Memoize()
+], ObjectType.prototype, "_discriminantProperty", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "ancestorObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "childObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantFromRdfTypeVariables", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantFromRdfTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "descendantObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "discriminantProperty", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "discriminantValue", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "equalsFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "filterFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "fromRdfTypeVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "hashFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "mutable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "parentObjectTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "properties", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "schemaType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfResourceValueTypes", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfjsResourceType", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "valueSparqlConstructTriplesFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "valueSparqlWherePatternsFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "thisVariable", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "jsonType", null);
+(function (ObjectType) {
+    ObjectType.IdentifierProperty = _IdentifierProperty;
+    ObjectType.ShaclProperty = _ShaclProperty;
+    ObjectType.DiscriminantProperty = _DiscriminantProperty;
+})(ObjectType || (ObjectType = {}));
+//# sourceMappingURL=ObjectType.js.map

package/dist/generators/ts/ObjectUnionType.d.ts

@@ -0,0 +1,20 @@
+import type { ObjectType } from "./ObjectType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+import { UnionType } from "./UnionType.js";
+export declare class ObjectUnionType extends UnionType<ObjectType> {
+    readonly kind = "ObjectUnion";
+    get identifierTypeAlias(): Code;
+    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get schema(): Code;
+    get schemaType(): Code;
+    protected get staticModuleDeclarations(): Record<string, Code>;
+    private get focusSparqlConstructTriplesFunctionDeclaration();
+    private get focusSparqlWherePatternsFunctionDeclaration();
+    private get fromRdfResourceFunctionDeclaration();
+    private get graphqlTypeVariableStatement();
+    private get identifierTypeDeclarations();
+    private get isTypeFunctionDeclaration();
+    private get schemaVariableStatement();
+    private get toRdfResourceFunctionDeclaration();
+}
+//# sourceMappingURL=ObjectUnionType.d.ts.map

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

@@ -6,44 +6,38 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { PropertyPath } from "@rdfx/resource";
 import { pascalCase } from "change-case";
-import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
-import { NamedObjectType_objectSetMethodNames } from "./_NamedObjectType/NamedObjectType_objectSetMethodNames.js";
-import { NamedObjectType_sparqlConstructQueryFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { NamedObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
-import { AbstractType } from "./AbstractType.js";
+import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
+import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
+import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
 import { singleEntryRecord } from "./singleEntryRecord.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-export class NamedObjectUnionType extends AbstractNamedUnionType {
-    #identifierType;
-    graphqlArgs = Maybe.empty();
-    kind = "NamedObjectUnionType";
-    synthetic;
-    constructor({ identifierType, synthetic, ...superParameters }) {
-        super({ ...superParameters, identifierType: Maybe.of(identifierType) });
-        this.#identifierType = identifierType;
-        this.synthetic = synthetic;
-    }
-    get graphqlType() {
-        return new AbstractType.GraphqlType(code `${this._name}.GraphQL`, this.reusables);
-    }
+import { UnionType } from "./UnionType.js";
+export class ObjectUnionType extends UnionType {
+    kind = "ObjectUnion";
     get identifierTypeAlias() {
-        return code `${this.name}.Identifier`;
+        return this.alias.map((alias) => code `${alias}.Identifier`).unsafeCoerce();
     }
     get objectSetMethodNames() {
-        return NamedObjectType_objectSetMethodNames.call({
+        return this.alias
+            .map((alias) => ObjectType_objectSetMethodNames.call({
+            alias,
             configuration: this.configuration,
-            name: this.name,
-        });
+        }))
+            .unsafeCoerce();
     }
     get schema() {
-        return code `${this.name}.schema`;
+        return this.alias
+            .map((alias) => code `${alias}.schema`)
+            .orDefault(super.schema);
     }
     get schemaType() {
-        return code `typeof ${this.schema}`;
+        return this.alias
+            .map(() => code `typeof ${this.schema}`)
+            .orDefault(super.schemaType);
     }
     get staticModuleDeclarations() {
+        const alias = this.alias.unsafeCoerce();
         return {
             ...super.staticModuleDeclarations,
             ...this.identifierTypeDeclarations,
@@ -53,18 +47,18 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
             ...this.graphqlTypeVariableStatement,
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
-            ...NamedObjectType_sparqlConstructQueryFunctionDeclaration.call({
+            ...ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                alias,
                 configuration: this.configuration,
                 filterType: this.filterType,
-                name: this.name,
                 reusables: this.reusables,
             })
                 .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
                 .orDefault({}),
-            ...NamedObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                alias,
                 configuration: this.configuration,
                 filterType: this.filterType,
-                name: this.name,
                 reusables: this.reusables,
             })
                 .map((code_) => singleEntryRecord(`sparqlConstructQueryString`, code_))
@@ -78,7 +72,7 @@ export class NamedObjectUnionType extends AbstractNamedUnionType {
         }
         return singleEntryRecord(`focusSparqlConstructTriples`, code `\
 export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
-  return [${joinCode(this.members.map((member) => code `...${member.type.name}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
@@ -91,18 +85,18 @@ ${joinCode([
             code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
             code `\
 if (focusIdentifier.termType === "Variable") {
-  patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
+  patterns = patterns.concat(${this.identifierType.unsafeCoerce().valueSparqlWherePatternsFunction}({
       filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
       ignoreRdfType: false,
       preferredLanguages,
       propertyPatterns: [],
-      schema: ${this.#identifierType.schema},
+      schema: ${this.identifierType.unsafeCoerce().schema},
       valueVariable: focusIdentifier,
       variablePrefix,
   }));
 }`,
             code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-                patterns: code `${member.type.name}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+                patterns: code `${member.type.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -113,10 +107,11 @@ if (focusIdentifier.termType === "Variable") {
         if (!this.configuration.features.has("Object.fromRdf")) {
             return {};
         }
+        const alias = this.alias.unsafeCoerce();
         return singleEntryRecord(`fromRdfResource`, code `\
-export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${alias}> = (resource, options) => 
   ${this.members.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.name}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${this.name}>)`;
+            const memberTypeExpression = code `(${member.type.alias.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${alias}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -129,11 +124,12 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         if (this.synthetic) {
             return {};
         }
+        const alias = this.alias.unsafeCoerce();
         return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
-            name: this.name,
-            resolveType: code `(value: ${this.name}) => value.${this.configuration.syntheticNamePrefix}type`,
+            name: alias,
+            resolveType: code `(value: ${alias}) => value.${this.configuration.syntheticNamePrefix}type`,
             types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
         }});`);
     }
@@ -142,22 +138,23 @@ export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             return {};
         }
         return singleEntryRecord(`Identifier`, code `\
-export type Identifier = ${this.#identifierType.name};
+export type Identifier = ${this.identifierType.unsafeCoerce().expression};
 export namespace Identifier {
-  export const parse = ${this.#identifierType.parseFunction};
-  export const stringify = ${this.#identifierType.stringifyFunction};
+  export const parse = ${this.identifierType.unsafeCoerce().parseFunction};
+  export const stringify = ${this.identifierType.unsafeCoerce().stringifyFunction};
 }`);
     }
     get isTypeFunctionDeclaration() {
         if (!this.configuration.features.has("Object.type")) {
             return {};
         }
-        if (this._name === `${this.configuration.syntheticNamePrefix}Object`) {
+        const alias = this.alias.unsafeCoerce();
+        if (alias === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
-        return singleEntryRecord(`is${this._name}`, code `\
-    export function is${this._name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${this.name} {
-      return ${joinCode(this.members.map((member) => code `${member.type.name}.is${member.type.name}(object)`), { on: " || " })};
+        return singleEntryRecord(`is${alias}`, code `\
+    export function is${alias}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${alias} {
+      return ${joinCode(this.members.map((member) => code `${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)`), { on: " || " })};
     }`);
     }
     get schemaVariableStatement() {
@@ -167,7 +164,7 @@ export namespace Identifier {
         const commonPropertiesByName = {};
         this.members.forEach((member, memberI) => {
             for (const memberTypeProperty of member.type.properties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.properties))) {
-                if (memberTypeProperty.kind !== "ShaclProperty") {
+                if (memberTypeProperty.kind !== "Shacl") {
                     continue;
                 }
                 let commonProperty = commonPropertiesByName[memberTypeProperty.name];
@@ -191,43 +188,36 @@ export namespace Identifier {
             if (!memberTypesWithProperty.every((value) => value)) {
                 continue;
             }
-            propertiesObject.push(code `${property.name}: ${property.schema}`);
+            property.schema.ifJust((propertySchema) => {
+                propertiesObject.push(code `${property.name}: ${propertySchema}`);
+            });
         }
         return singleEntryRecord(`schema`, code `\
-export const schema =
-${{
-            ...super.schemaObject,
-            properties: code `{ ${joinCode(propertiesObject, { on: ", " })} }`,
-        }} as const;`);
+export const schema = { ${joinCode(super.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
     }
     get toRdfResourceFunctionDeclaration() {
         if (!this.configuration.features.has("Object.toRdf")) {
             return {};
         }
+        const alias = this.alias.unsafeCoerce();
         return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${this.name}> = (object, options) => {
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${alias}> = (object, options) => {
 ${joinCode(this.members
-            .map((member) => code `if (${member.type.name}.is${member.type.name}(object)) { return ${member.type.name}.toRdfResource(object, options); }`)
+            .map((member) => code `if (${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)) { return ${member.type.alias.unsafeCoerce()}.toRdfResource(object, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
 }
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], NamedObjectUnionType.prototype, "identifierTypeAlias", null);
+], ObjectUnionType.prototype, "identifierTypeAlias", null);
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "objectSetMethodNames", null);
+], ObjectUnionType.prototype, "objectSetMethodNames", null);
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "schema", null);
+], ObjectUnionType.prototype, "schema", null);
 __decorate([
     Memoize()
-], NamedObjectUnionType.prototype, "schemaType", null);
-//# sourceMappingURL=NamedObjectUnionType.js.map
+], ObjectUnionType.prototype, "schemaType", null);
+//# sourceMappingURL=ObjectUnionType.js.map

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

@@ -4,24 +4,20 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
     readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
     readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
-    readonly kind = "OptionType";
+    readonly kind = "Option";
     readonly typeofs: "object"[];
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
+    get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
-    get name(): Code;
     get schemaType(): Code;
     get validationFunction(): Maybe<Code>;
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaObject(): {
-        kind: Code;
-        item: Code;
-    };
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;