@shaclmate/compiler 4.0.7 → 4.0.9

package/dist/generators/ts/NamedObjectUnionType.js

@@ -0,0 +1,221 @@
+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 { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { PropertyPath } from "rdfjs-resource";
+import { Memoize } from "typescript-memoize";
+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 { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+import { AbstractType } from "./AbstractType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
+function singleEntryRecord(key, value) {
+    const record = {};
+    record[key] = value;
+    return record;
+}
+export class NamedObjectUnionType extends AbstractNamedUnionType {
+    #identifierType;
+    graphqlArgs = Maybe.empty();
+    kind = "NamedObjectUnionType";
+    constructor({ identifierType, ...superParameters }) {
+        super({ ...superParameters, identifierType: Maybe.of(identifierType) });
+        this.#identifierType = identifierType;
+    }
+    get graphqlType() {
+        return new AbstractType.GraphqlType(code `${this._name}.${syntheticNamePrefix}GraphQL`);
+    }
+    get identifierTypeAlias() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}Identifier`;
+    }
+    get objectSetMethodNames() {
+        return ObjectType_objectSetMethodNames.call(this);
+    }
+    get schema() {
+        return code `${this.staticModuleName}.${syntheticNamePrefix}schema`;
+    }
+    get schemaType() {
+        return code `typeof ${this.schema}`;
+    }
+    get staticModuleDeclarations() {
+        return {
+            ...super.staticModuleDeclarations,
+            ...this.identifierTypeDeclarations,
+            ...this.focusSparqlConstructTriplesFunctionDeclaration,
+            ...this.focusSparqlWherePatternsFunctionDeclaration,
+            ...this.fromRdfResourceFunctionDeclaration,
+            ...this.graphqlTypeVariableStatement,
+            ...this.isTypeFunctionDeclaration,
+            ...this.schemaVariableStatement,
+            ...ObjectType_sparqlConstructQueryFunctionDeclaration.call(this)
+                .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQuery`, code_))
+                .orDefault({}),
+            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call(this)
+                .map((code_) => singleEntryRecord(`${syntheticNamePrefix}sparqlConstructQueryString`, code_))
+                .orDefault({}),
+            ...this.toRdfResourceFunctionDeclaration,
+        };
+    }
+    get focusSparqlConstructTriplesFunctionDeclaration() {
+        if (!this.features.has("sparql")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}focusSparqlConstructTriples`, code `\
+export function ${syntheticNamePrefix}focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+  return [${joinCode(this.concreteMembers.map((member) => code `...${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`), { on: ", " })}];
+}`);
+    }
+    get focusSparqlWherePatternsFunctionDeclaration() {
+        if (!this.features.has("sparql")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}focusSparqlWherePatterns`, code `\
+export function ${syntheticNamePrefix}focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${joinCode([
+            code `let patterns: ${snippets.SparqlPattern}[] = [];`,
+            code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.#identifierType.valueSparqlWherePatternsFunction}({
+      filter: filter?.${syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.#identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+            code `patterns.push({ patterns: [${joinCode(this.concreteMembers.map((member) => code `${{
+                patterns: code `${member.type.staticModuleName}.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name)}\` }).concat()`,
+                type: literalOf("group"),
+            }}`), { on: ", " })}], type: "union" });`,
+            code `return patterns;`,
+        ])}
+}`);
+    }
+    get fromRdfResourceFunctionDeclaration() {
+        if (!this.features.has("rdf")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}fromRdfResource`, code `\
+export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => 
+  ${this.concreteMembers.reduce((expression, member) => {
+            const memberTypeExpression = code `(${member.type.staticModuleName}.${syntheticNamePrefix}fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+            return expression !== null
+                ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+                : memberTypeExpression;
+        }, null)};`);
+    }
+    get graphqlTypeVariableStatement() {
+        if (!this.features.has("graphql")) {
+            return {};
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}GraphQL`, code `\
+export const ${syntheticNamePrefix}GraphQL = new ${imports.GraphQLUnionType}(${{
+            description: this.comment.map(JSON.stringify).extract(),
+            name: this.name,
+            resolveType: code `(value: ${this.name}) => value.${syntheticNamePrefix}type`,
+            types: code `[${joinCode(this.concreteMembers.map((member) => member.type.graphqlType.nullableName), { on: ", " })}]`,
+        }});`);
+    }
+    get identifierTypeDeclarations() {
+        return singleEntryRecord(`${syntheticNamePrefix}Identifier`, code `\
+export type ${syntheticNamePrefix}Identifier = ${this.#identifierType.name};
+export namespace ${syntheticNamePrefix}Identifier { ${joinCode([this.#identifierType.fromStringFunction, this.#identifierType.toStringFunction])} }`);
+    }
+    get isTypeFunctionDeclaration() {
+        if (this._name === `${syntheticNamePrefix}Object`) {
+            return {};
+        }
+        return singleEntryRecord(`is${this._name}`, code `\
+    export function is${this._name}(object: ${syntheticNamePrefix}Object): object is ${this.name} {
+      return ${joinCode(this.concreteMembers.map((member) => code `${member.type.staticModuleName}.is${member.type.name}(object)`), { on: " || " })};
+    }`);
+    }
+    get schemaVariableStatement() {
+        const commonPropertiesByName = {};
+        this.concreteMembers.forEach((member, memberI) => {
+            for (const memberTypeProperty of member.type.ownProperties.concat(member.type.ancestorObjectTypes.flatMap((ancestorObjectType) => ancestorObjectType.ownProperties))) {
+                if (memberTypeProperty.kind !== "ShaclProperty") {
+                    continue;
+                }
+                let commonProperty = commonPropertiesByName[memberTypeProperty.name];
+                if (commonProperty) {
+                    if (PropertyPath.equals(commonProperty.property.path, memberTypeProperty.path)) {
+                        commonProperty.memberTypesWithProperty[memberI] = true;
+                    }
+                }
+                else {
+                    commonPropertiesByName[memberTypeProperty.name] = commonProperty = {
+                        memberTypesWithProperty: new Array(this.concreteMembers.length).fill(false),
+                        property: memberTypeProperty,
+                    };
+                    commonProperty.memberTypesWithProperty[memberI] = true;
+                }
+            }
+        });
+        const propertiesObject = [];
+        for (const name of Object.keys(commonPropertiesByName).toSorted()) {
+            const { memberTypesWithProperty, property } = commonPropertiesByName[name];
+            if (!memberTypesWithProperty.every((value) => value)) {
+                continue;
+            }
+            propertiesObject.push(code `${property.name}: ${property.schema}`);
+        }
+        return singleEntryRecord(`${syntheticNamePrefix}schema`, code `\
+export const ${syntheticNamePrefix}schema =
+${{
+            ...super.schemaObject,
+            properties: code `{ ${joinCode(propertiesObject, { on: ", " })} }`,
+        }} as const;`);
+    }
+    get toRdfResourceFunctionDeclaration() {
+        if (!this.features.has("rdf")) {
+            return {};
+        }
+        return singleEntryRecord(``, code `\
+export const ${syntheticNamePrefix}toRdfResource: ${snippets.ToRdfResourceFunction}<${this.name}> = (value, options) => {
+${joinCode(this.concreteMembers
+            .map((member) => {
+            let returnExpression;
+            switch (member.type.declarationType) {
+                case "class":
+                    returnExpression = code `value.${syntheticNamePrefix}toRdfResource(options)`;
+                    break;
+                case "interface":
+                    returnExpression = code `${member.type.staticModuleName}.${syntheticNamePrefix}toRdfResource(value, options)`;
+                    break;
+            }
+            return code `if (${member.type.staticModuleName}.is${member.type.name}(value)) { return ${returnExpression}; }`;
+        })
+            .concat(code `throw new Error("unrecognized type");`))}
+};`);
+    }
+    graphqlResolveExpression({ variables, }) {
+        return variables.value;
+    }
+}
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "graphqlType", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "identifierTypeAlias", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "objectSetMethodNames", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "schema", null);
+__decorate([
+    Memoize()
+], NamedObjectUnionType.prototype, "schemaType", null);
+//# sourceMappingURL=NamedObjectUnionType.js.map

package/dist/generators/ts/NamedUnionType.d.ts

@@ -0,0 +1,11 @@
+import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+import type { AbstractType } from "./AbstractType.js";
+import type { Type } from "./Type.js";
+import type { Code } from "./ts-poet-wrapper.js";
+export declare class NamedUnionType extends AbstractNamedUnionType<Type> {
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
+    readonly kind = "NamedUnionType";
+    graphqlResolveExpression(): Code;
+    get graphqlType(): AbstractType.GraphqlType;
+}
+//# sourceMappingURL=NamedUnionType.d.ts.map

package/dist/generators/ts/NamedUnionType.js

@@ -0,0 +1,13 @@
+import { Maybe } from "purify-ts";
+import { AbstractNamedUnionType } from "./AbstractNamedUnionType.js";
+export class NamedUnionType extends AbstractNamedUnionType {
+    graphqlArgs = Maybe.empty();
+    kind = "NamedUnionType";
+    graphqlResolveExpression() {
+        throw new Error("GraphQL doesn't support scalar unions");
+    }
+    get graphqlType() {
+        throw new Error("GraphQL doesn't support scalar unions");
+    }
+}
+//# sourceMappingURL=NamedUnionType.js.map

package/dist/generators/ts/ObjectType.d.ts

@@ -1,65 +1,71 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe, NonEmptyList } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
+import type { TsFeature } from "../../enums/TsFeature.js";
 import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
+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 type { Property as _Property } from "./_ObjectType/Property.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 type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractDeclaredType {
+export declare class ObjectType extends AbstractType {
     private readonly imports;
     protected readonly toRdfTypes: readonly NamedNode[];
     readonly abstract: boolean;
     readonly declarationType: TsObjectDeclarationType;
     readonly extern: boolean;
+    readonly features: ReadonlySet<TsFeature>;
     readonly fromRdfType: Maybe<NamedNode>;
-    readonly graphqlArgs: AbstractDeclaredType["graphqlArgs"];
+    readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly kind = "ObjectType";
+    readonly name: string;
+    readonly recursive: boolean;
     readonly staticModuleName: string;
     readonly synthetic: boolean;
     readonly 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 }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
         extern: boolean;
+        features: ReadonlySet<TsFeature>;
         fromRdfType: Maybe<NamedNode>;
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierType: BlankNodeType | IdentifierType | IriType;
         imports: readonly string[];
         label: Maybe<string>;
         lazyAncestorObjectTypes: () => readonly ObjectType[];
         lazyChildObjectTypes: () => readonly ObjectType[];
+        lazyDiscriminantProperty: (objectType: ObjectType) => ObjectType.DiscriminantProperty;
+        lazyIdentifierProperty: (objectType: ObjectType) => ObjectType.IdentifierProperty;
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
         lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
+        name: string;
+        recursive: boolean;
         staticModuleName: string;
         synthetic: boolean;
         toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof AbstractDeclaredType>[0]);
-    get _discriminantProperty(): AbstractDeclaredType.DiscriminantProperty;
+    } & ConstructorParameters<typeof AbstractType>[0]);
     get ancestorObjectTypes(): readonly ObjectType[];
     get childObjectTypes(): readonly ObjectType[];
-    get conversions(): readonly AbstractDeclaredType.Conversion[];
-    get declaration(): Code;
+    get conversions(): readonly AbstractType.Conversion[];
+    get declaration(): Maybe<Code>;
     get descendantFromRdfTypeVariables(): readonly Code[];
     get descendantFromRdfTypes(): readonly NamedNode[];
     get descendantObjectTypes(): readonly ObjectType[];
-    get discriminantProperty(): Maybe<AbstractDeclaredType.DiscriminantProperty>;
+    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
     get discriminantValue(): string;
     get equalsFunction(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
     get fromRdfTypeVariable(): Maybe<Code>;
-    get graphqlType(): AbstractDeclaredType.GraphqlType;
+    get graphqlType(): AbstractType.GraphqlType;
     get identifierProperty(): ObjectType.IdentifierProperty;
     get identifierTypeAlias(): Code;
     get mutable(): boolean;
@@ -70,30 +76,33 @@ export declare class ObjectType extends AbstractDeclaredType {
     get properties(): readonly ObjectType.Property[];
     get schema(): Code;
     get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
+    get valueSparqlConstructTriplesFunction(): Code;
+    get valueSparqlWherePatternsFunction(): Code;
     get toRdfjsResourceType(): Code;
+    get _discriminantProperty(): ObjectType.DiscriminantProperty;
     protected get thisVariable(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractDeclaredType["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression({ variables, }: Parameters<AbstractDeclaredType["fromRdfExpression"]>[0]): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
+    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
             value: Code;
         };
     }): Code;
-    hashStatements({ variables, }: Parameters<AbstractDeclaredType["hashStatements"]>[0]): readonly Code[];
-    jsonType(): AbstractDeclaredType.JsonType;
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractDeclaredType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema({ context, }: Parameters<AbstractDeclaredType["jsonZodSchema"]>[0]): Code;
+    hashStatements({ variables, }: Parameters<AbstractType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractType.JsonType;
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    jsonZodSchema({ context, }: Parameters<AbstractType["jsonZodSchema"]>[0]): Code;
     newExpression({ parameters }: {
         parameters: Code;
     }): Code;
-    toJsonExpression({ variables, }: Parameters<AbstractDeclaredType["toJsonExpression"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractDeclaredType["toRdfExpression"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
+    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     protected ensureAtMostOneSuperObjectType(): void;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyChildObjectTypes;
     private readonly lazyDescendantObjectTypes;
+    private readonly lazyDiscriminantProperty;
+    private readonly lazyIdentifierProperty;
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
 }
@@ -111,7 +120,7 @@ export declare namespace ObjectType {
     type Property = _Property;
     const ShaclProperty: typeof _ShaclProperty;
     type ShaclProperty<TypeT extends Type> = _ShaclProperty<TypeT>;
-    const TypeDiscriminantProperty: typeof _TypeDiscriminantProperty;
-    type TypeDiscriminantProperty = _TypeDiscriminantProperty;
+    const DiscriminantProperty: typeof _DiscriminantProperty;
+    type DiscriminantProperty = _DiscriminantProperty;
 }
 //# sourceMappingURL=ObjectType.d.ts.map