@shaclmate/compiler 4.0.41 → 4.0.42

package/dist/generators/ts/ObjectUnionType.js

@@ -16,28 +16,28 @@ import { UnionType } from "./UnionType.js";
 export class ObjectUnionType extends UnionType {
     kind = "ObjectUnion";
     get identifierTypeAlias() {
-        return this.alias.map((alias) => code `${alias}.Identifier`).unsafeCoerce();
+        return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
     }
     get objectSetMethodNames() {
-        return this.alias
-            .map((alias) => ObjectType_objectSetMethodNames.call({
-            alias,
+        return this.name
+            .map((name) => ObjectType_objectSetMethodNames.call({
+            name,
             configuration: this.configuration,
         }))
             .unsafeCoerce();
     }
     get schema() {
-        return this.alias
-            .map((alias) => code `${alias}.schema`)
+        return this.name
+            .map((name) => code `${name}.schema`)
             .orDefault(super.schema);
     }
     get schemaType() {
-        return this.alias
+        return this.name
             .map(() => code `typeof ${this.schema}`)
             .orDefault(super.schemaType);
     }
     get staticModuleDeclarations() {
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return {
             ...super.staticModuleDeclarations,
             ...this.identifierTypeDeclarations,
@@ -47,22 +47,22 @@ export class ObjectUnionType extends UnionType {
             ...this.graphqlTypeVariableStatement,
             ...this.isTypeFunctionDeclaration,
             ...this.schemaVariableStatement,
-            ...ObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                alias,
-                configuration: this.configuration,
-                filterType: this.filterType,
-                reusables: this.reusables,
-            })
-                .map((code_) => singleEntryRecord(`sparqlConstructQuery`, code_))
-                .orDefault({}),
-            ...ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                alias,
-                configuration: this.configuration,
-                filterType: this.filterType,
-                reusables: this.reusables,
-            })
-                .map((code_) => singleEntryRecord(`sparqlConstructQueryString`, code_))
-                .orDefault({}),
+            ...(this.configuration.features.has("Object.SPARQL")
+                ? {
+                    ...singleEntryRecord("sparqlConstructQuery", ObjectType_sparqlConstructQueryFunctionDeclaration.call({
+                        name,
+                        configuration: this.configuration,
+                        filterType: this.filterType,
+                        reusables: this.reusables,
+                    })),
+                    ...singleEntryRecord("sparqlConstructQueryString", ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
+                        name,
+                        configuration: this.configuration,
+                        filterType: this.filterType,
+                        reusables: this.reusables,
+                    })),
+                }
+                : {}),
             ...this.toRdfResourceFunctionDeclaration,
         };
     }
@@ -72,7 +72,7 @@ export class ObjectUnionType extends UnionType {
         }
         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.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.alias.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.alias.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
+  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
 }`);
     }
     get focusSparqlWherePatternsFunctionDeclaration() {
@@ -96,7 +96,7 @@ if (focusIdentifier.termType === "Variable") {
   }));
 }`,
             code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
-                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()`,
+                patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
                 type: literalOf("group"),
             }}`), { on: ", " })}], type: "union" });`,
             code `return patterns;`,
@@ -107,11 +107,11 @@ if (focusIdentifier.termType === "Variable") {
         if (!this.configuration.features.has("Object.fromRdf")) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return singleEntryRecord(`fromRdfResource`, code `\
-export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${alias}> = (resource, options) => 
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${name}> = (resource, options) => 
   ${this.members.reduce((expression, member) => {
-            const memberTypeExpression = code `(${member.type.alias.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${alias}>)`;
+            const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${name}>)`;
             return expression !== null
                 ? code `${expression}.altLazy(() => ${memberTypeExpression})`
                 : memberTypeExpression;
@@ -124,12 +124,12 @@ export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}
         if (this.synthetic) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return singleEntryRecord(`GraphQL`, code `\
 export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
             description: this.comment.map(JSON.stringify).extract(),
-            name: alias,
-            resolveType: code `(value: ${alias}) => value.${this.configuration.syntheticNamePrefix}type`,
+            name: name,
+            resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
             types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
         }});`);
     }
@@ -148,13 +148,13 @@ export namespace Identifier {
         if (!this.configuration.features.has("Object.type")) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
-        if (alias === `${this.configuration.syntheticNamePrefix}Object`) {
+        const name = this.name.unsafeCoerce();
+        if (name === `${this.configuration.syntheticNamePrefix}Object`) {
             return {};
         }
-        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: " || " })};
+        return singleEntryRecord(`is${name}`, code `\
+    export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
+      return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
     }`);
     }
     get schemaVariableStatement() {
@@ -199,11 +199,11 @@ export const schema = { ${joinCode(super.schemaInitializers.concat(code `propert
         if (!this.configuration.features.has("Object.toRdf")) {
             return {};
         }
-        const alias = this.alias.unsafeCoerce();
+        const name = this.name.unsafeCoerce();
         return singleEntryRecord(`toRdfResource`, code `\
-export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${alias}> = (object, options) => {
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${name}> = (object, options) => {
 ${joinCode(this.members
-            .map((member) => code `if (${member.type.alias.unsafeCoerce()}.is${member.type.alias.unsafeCoerce()}(object)) { return ${member.type.alias.unsafeCoerce()}.toRdfResource(object, options); }`)
+            .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
             .concat(code `throw new Error("unrecognized type");`))}
 };`);
     }

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

@@ -4,16 +4,17 @@ 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 = "Option";
     readonly jsTypes: readonly [{
         readonly instanceof: "Maybe";
         readonly typeof: "object";
     }];
+    readonly kind = "Option";
     get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
     get equalsFunction(): Code;
     get expression(): Code;
     get filterFunction(): Code;
     get filterType(): Code;
+    get fromRdfResourceValuesFunction(): Code;
     get graphqlType(): AbstractContainerType.GraphqlType;
     get hashFunction(): Code;
     get mutable(): boolean;
@@ -23,7 +24,6 @@ export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends A
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): 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;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;

package/dist/generators/ts/OptionType.js

@@ -13,10 +13,10 @@ import { code } from "./ts-poet-wrapper.js";
 export class OptionType extends AbstractContainerType {
     discriminantProperty = Maybe.empty();
     graphqlArgs = Maybe.empty();
-    kind = "Option";
     jsTypes = [
         { instanceof: "Maybe", typeof: "object" },
     ];
+    kind = "Option";
     get conversionFunction() {
         const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
         return Maybe.of({
@@ -42,6 +42,9 @@ export class OptionType extends AbstractContainerType {
     get filterType() {
         return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
     }
+    get fromRdfResourceValuesFunction() {
+        return code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
     get graphqlType() {
         invariant(!this.itemType.graphqlType.nullable);
         return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.expression, this.reusables, {
@@ -76,10 +79,6 @@ export class OptionType extends AbstractContainerType {
         });
         return code `${expression}.map(item => (${itemFromJsonExpression}).map(${this.reusables.imports.Maybe}.of)).orDefault(${this.reusables.imports.Either}.of(${this.reusables.imports.Maybe}.empty()))`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return code `${this.itemType.fromRdfResourceValuesExpression(parameters)}.map(values => values.length > 0 ? values.map(value => ${this.reusables.imports.Maybe}.of(value)) : ${this.reusables.imports.Resource}.Values.fromValue<${this.reusables.imports.Maybe}<${this.itemType.expression}>>({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: ${this.reusables.imports.Maybe}.empty() }))`;
-    }
     graphqlResolveExpression(parameters) {
         return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
     }
@@ -128,6 +127,9 @@ __decorate([
 __decorate([
     Memoize()
 ], OptionType.prototype, "filterType", null);
+__decorate([
+    Memoize()
+], OptionType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], OptionType.prototype, "graphqlType", null);

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

@@ -4,22 +4,22 @@ import type { AbstractContainerType } from "./AbstractContainerType.js";
 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 = "Set";
-    readonly minCount: bigint;
     readonly jsTypes: readonly [{
         readonly instanceof: "Array";
         readonly typeof: "object";
     }];
+    readonly kind = "Set";
+    readonly minCount: bigint;
     constructor({ minCount, ...superParameters }: {
         minCount: bigint;
     } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
     get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get fromRdfResourceValuesFunction(): Code;
     get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaInitializers(): readonly Code[];
     fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
     jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/SetType.js

@@ -11,11 +11,11 @@ import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
-    kind = "Set";
-    minCount;
     jsTypes = [
         { instanceof: "Array", typeof: "object" },
     ];
+    kind = "Set";
+    minCount;
     constructor({ minCount, ...superParameters }) {
         super(superParameters);
         this.minCount = minCount;
@@ -54,6 +54,9 @@ export class SetType extends AbstractCollectionType {
             sourceTypes,
         });
     }
+    get fromRdfResourceValuesFunction() {
+        return code `${this._mutable ? this.reusables.snippets.mutableSetFromRdfResourceValues : this.reusables.snippets.setFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
+    }
     get toRdfResourceValueTypes() {
         return this.itemType.toRdfResourceValueTypes;
     }
@@ -79,14 +82,6 @@ export class SetType extends AbstractCollectionType {
             variables: { value: code `item` },
         })})))`;
     }
-    fromRdfResourceValuesExpression(parameters) {
-        const { variables } = parameters;
-        return joinCode([
-            this.itemType.fromRdfResourceValuesExpression(parameters),
-            code `map(values => values.toArray()${this._mutable ? ".concat()" : ""})`,
-            code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`,
-        ], { on: "." });
-    }
     jsonSchema(parameters) {
         let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
         if (this.minCount > 0n) {
@@ -119,6 +114,9 @@ export class SetType extends AbstractCollectionType {
 __decorate([
     Memoize()
 ], SetType.prototype, "conversionFunction", null);
+__decorate([
+    Memoize()
+], SetType.prototype, "fromRdfResourceValuesFunction", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/Snippets.d.ts

@@ -34,9 +34,9 @@ export declare class Snippets {
     get IdentifierSet(): Snippet;
     get IriFilter(): Snippet;
     get IriSchema(): Snippet;
-    get LazyObject(): Snippet;
-    get LazyObjectOption(): Snippet;
-    get LazyObjectSet(): Snippet;
+    get Lazy(): Snippet;
+    get LazyOption(): Snippet;
+    get LazySet(): Snippet;
     get LiteralFilter(): Snippet;
     get LiteralSchema(): Snippet;
     get MaybeFilter(): Snippet;
@@ -63,10 +63,14 @@ export declare class Snippets {
     get _ToRdfResourceFunction(): Snippet;
     get arrayEquals(): Snippet;
     get arrayIntersection(): Snippet;
+    get bigDecimalFromRdfResourceValues(): Snippet;
     get bigDecimalLiteral(): Snippet;
     get bigDecimalSparqlWherePatterns(): Snippet;
+    get bigIntFromRdfResourceValues(): Snippet;
+    get blankNodeFromRdfResourceValues(): Snippet;
     get blankNodeSparqlWherePatterns(): Snippet;
     get booleanEquals(): Snippet;
+    get booleanFromRdfResourceValues(): Snippet;
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
     get convertToArraySet(): Snippet;
@@ -76,18 +80,21 @@ export declare class Snippets {
     get convertToIdentifierProperty(): Snippet;
     get convertToIri(): Snippet;
     get convertToIriIdentifierProperty(): Snippet;
-    get convertToLazyObject(): Snippet;
-    get convertToLazyObjectOption(): Snippet;
-    get convertToLazyObjectSet(): Snippet;
+    get convertToLazy(): Snippet;
+    get convertToLazyOption(): Snippet;
+    get convertToLazySet(): Snippet;
     get convertToList(): Snippet;
     get convertToLiteral(): Snippet;
     get convertToMaybe(): Snippet;
     get convertToScalarSet(): Snippet;
     get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
+    get dateFromRdfResourceValues(): Snippet;
     get dateSparqlWherePatterns(): Snippet;
+    get dateTimeFromRdfResourceValues(): Snippet;
     get decodeBigDecimalLiteral(): Snippet;
     get deduplicateSparqlPatterns(): Snippet;
+    get defaultValueFromRdfResourceValues(): Snippet;
     get defaultValueSparqlWherePatterns(): Snippet;
     get ensureRdfResourceType(): Snippet;
     get filterArray(): Snippet;
@@ -102,8 +109,7 @@ export declare class Snippets {
     get filterNumeric(): Snippet;
     get filterString(): Snippet;
     get filterTerm(): Snippet;
-    get fromRdfLanguageIn(): Snippet;
-    get fromRdfPreferredLanguages(): Snippet;
+    get floatFromRdfResourceValues(): Snippet;
     get hashArray(): Snippet;
     get hashBigDecimal(): Snippet;
     get hashBoolean(): Snippet;
@@ -113,27 +119,36 @@ export declare class Snippets {
     get hashNumeric(): Snippet;
     get hashString(): Snippet;
     get hashTerm(): Snippet;
+    get identifierFromRdfResourceValues(): Snippet;
     get identifierSparqlWherePatterns(): Snippet;
     get identityConversionFunction(): Snippet;
     get identityValidationFunction(): Snippet;
     get ifUsed(): Code[];
+    get intFromRdfResourceValues(): Snippet;
+    get iriFromRdfResourceValues(): Snippet;
     get iriSparqlWherePatterns(): Snippet;
     get liftSparqlPatterns(): Snippet;
+    get listFromRdfResourceValues(): Snippet;
     get listSparqlConstructTriples(): Snippet;
     get listSparqlWherePatterns(): Snippet;
     get literalFactory(): Snippet;
+    get literalFromRdfResourceValues(): Snippet;
     get literalSchemaSparqlPatterns(): Snippet;
     get literalSparqlWherePatterns(): Snippet;
     get maybeEquals(): Snippet;
+    get maybeFromRdfResourceValues(): Snippet;
     get maybeSparqlConstructTriples(): Snippet;
     get maybeSparqlWherePatterns(): Snippet;
     get monkeyPatchObject(): Snippet;
+    get mutableListFromRdfResourceValues(): Snippet;
+    get mutableSetFromRdfResourceValues(): Snippet;
     get normalizeSparqlWherePatterns(): Snippet;
     get numericSparqlWherePatterns(): Snippet;
     get parseBlankNode(): Snippet;
     get parseIdentifier(): Snippet;
     get parseIri(): Snippet;
     get sequenceRecord(): Snippet;
+    get setFromRdfResourceValues(): Snippet;
     get setSparqlConstructTriples(): Snippet;
     get setSparqlWherePatterns(): Snippet;
     get shaclPropertyFromRdf(): Snippet;
@@ -144,8 +159,11 @@ export declare class Snippets {
     get sparqlPropertyPath(): Snippet;
     get sparqlValueInPattern(): Snippet;
     get strictEquals(): Snippet;
+    get stringFromRdfResourceValues(): Snippet;
     get stringSparqlWherePatterns(): Snippet;
     get termFilterSparqlPatterns(): Snippet;
+    get termFromRdfResourceValues(): Snippet;
+    get termLikeFromRdfResourceValues(): Snippet;
     get termSchemaSparqlPatterns(): Snippet;
     get termSparqlWherePatterns(): Snippet;
     get toIsoDateString(): Snippet;