@shaclmate/compiler 4.0.95 → 4.0.96

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -23,23 +23,23 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
         partialType: PartialTypeT;
         resolveType: ResolveTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
-    get jsonValueType(): AbstractType["jsonValueType"];
     get equalsFunction(): Callable;
-    get jsonObjectType(): AbstractType["jsonObjectType"];
     get filterFunction(): Callable;
     get filterType(): Code;
-    get fromJsonValueFunction(): AbstractType["fromJsonValueFunction"];
     get fromJsonObjectFunction(): AbstractType["fromJsonObjectFunction"];
+    get fromJsonValueFunction(): AbstractType["fromJsonValueFunction"];
     get fromRdfResourceValuesFunction(): Callable;
     get graphqlType(): AbstractType.GraphqlType;
     get hashFunction(): Callable;
     get inlineExpression(): Code;
     get jsTypes(): readonly AbstractType.JsType[];
+    get jsonObjectType(): AbstractType["jsonObjectType"];
+    get jsonValueType(): AbstractType["jsonValueType"];
     get recursive(): boolean;
     get referencesNamedType(): boolean;
     get schemaType(): Code;
-    get toJsonValueFunction(): AbstractType["toJsonValueFunction"];
     get toJsonObjectFunction(): AbstractType["toJsonObjectFunction"];
+    get toJsonValueFunction(): AbstractType["toJsonValueFunction"];
     get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Callable;
     get valueSparqlWherePatternsFunction(): Callable;
@@ -47,9 +47,11 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
     toLoggableExpression({ variables, }: Parameters<AbstractType["toLoggableExpression"]>[0]): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    protected abstract objectSetResolverFunctionExpressions(parameters: {
+    protected abstract objectSetResolveExpression(parameters: {
         variables: {
             objectSet: Code;
+            partial: Code;
+            resolverOptions: Code;
         };
     }): Code;
     protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyType.ItemTypeConstraint>({ partialType, resolveType, }: {
@@ -63,6 +65,11 @@ export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazy
             resolvedObjectDiscriminatedUnion: Code;
         };
     }): Code;
+    protected resolverFunctionExpression({ variables, }: {
+        variables: {
+            factoryFunctionOptions: Code;
+        };
+    }): Code;
 }
 export declare namespace AbstractLazyType {
     type ItemTypeConstraint = ObjectType | ObjectDiscriminatedUnionType;

package/dist/generators/ts/AbstractLazyType.js

@@ -21,17 +21,11 @@ export class AbstractLazyType extends AbstractType {
         this.partialType = partialType;
         this.resolveType = resolveType;
     }
-    get jsonValueType() {
-        return this.partialType.jsonValueType;
-    }
     get equalsFunction() {
         return new InlineCallable(code `(left, right) => ${this.partialType.equalsFunction.annotatedUsage}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.EqualsFunction}<${this.expression}>`,
         });
     }
-    get jsonObjectType() {
-        return this.partialType.jsonObjectType;
-    }
     get filterFunction() {
         return new InlineCallable(code `(filter, value) => ${this.partialType.filterFunction.annotatedUsage}(filter, value.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.FilterFunction}<${this.filterType}, ${this.expression}>`,
@@ -40,23 +34,23 @@ export class AbstractLazyType extends AbstractType {
     get filterType() {
         return this.partialType.filterType;
     }
-    get fromJsonValueFunction() {
-        return new InlineCallable(code `(jsonValue, { objectSet, schema, ...otherOptions }) => ${this.partialType.fromJsonValueFunction.annotatedUsage}(jsonValue, { objectSet, schema: schema.partialType, ...otherOptions })
-        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: objectSet ? ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} : ${this.reusables.snippets.missingResolver} }))`, {
-            type: code `${this.reusables.snippets.FromJsonValueFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema}>`,
-        });
-    }
     get fromJsonObjectFunction() {
-        return new InlineCallable(code `(jsonObject, { objectSet, schema, ...otherOptions }) => ${this.partialType.fromJsonObjectFunction.annotatedUsage}(jsonObject, { objectSet, schema: schema.partialType, ...otherOptions })
-        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: objectSet ? ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} : ${this.reusables.snippets.missingResolver} }))`, {
+        return new InlineCallable(code `(jsonObject, fromJsonObjectOptions) => ${this.partialType.fromJsonObjectFunction.annotatedUsage}(jsonObject, { ...fromJsonObjectOptions, schema: fromJsonObjectOptions.schema.partialType })
+        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromJsonObjectOptions` } })} }))`, {
             type: code `${this.reusables.snippets.FromJsonObjectFunction}<${this.jsonObjectType.expression}, ${this.expression}, ${this.schema}>`,
         });
     }
+    get fromJsonValueFunction() {
+        return new InlineCallable(code `(jsonValue, fromJsonValueOptions) => ${this.partialType.fromJsonValueFunction.annotatedUsage}(jsonValue, { ...fromJsonValueOptions, schema: fromJsonValueOptions.schema.partialType })
+        .map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromJsonValueOptions` } })} }))`, {
+            type: code `${this.reusables.snippets.FromJsonValueFunction}<${this.jsonValueType.expression}, ${this.expression}, ${this.schema}>`,
+        });
+    }
     get fromRdfResourceValuesFunction() {
         return new InlineCallable(code `\
-  (values, { objectSet, schema, ...otherOptions }) =>
-    ${this.partialType.fromRdfResourceValuesFunction.annotatedUsage}(values, { objectSet, schema: schema.partialType, ...otherOptions })
-      .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.objectSetResolverFunctionExpressions({ variables: { objectSet: code `objectSet` } })} })))`, {
+  (values, fromRdfResourceValuesOptions) =>
+    ${this.partialType.fromRdfResourceValuesFunction.annotatedUsage}(values, { ...fromRdfResourceValuesOptions, schema: fromRdfResourceValuesOptions.schema.partialType })
+      .map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: ${this.resolverFunctionExpression({ variables: { factoryFunctionOptions: code `fromRdfResourceValuesOptions` } })} })))`, {
             type: code `${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.expression}, ${this.schemaType}>`,
         });
     }
@@ -78,6 +72,12 @@ export class AbstractLazyType extends AbstractType {
             },
         ];
     }
+    get jsonObjectType() {
+        return this.partialType.jsonObjectType;
+    }
+    get jsonValueType() {
+        return this.partialType.jsonValueType;
+    }
     get recursive() {
         return this.partialType.recursive;
     }
@@ -90,16 +90,16 @@ export class AbstractLazyType extends AbstractType {
             partialType: this.partialType.schemaType,
         }}`;
     }
-    get toJsonValueFunction() {
-        return new InlineCallable(code `(value) => ${this.partialType.toJsonValueFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
-            type: code `${this.reusables.snippets.ToJsonValueFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
-        });
-    }
     get toJsonObjectFunction() {
         return new InlineCallable(code `(value) => ${this.partialType.toJsonObjectFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
             type: code `${this.reusables.snippets.ToJsonObjectFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
         });
     }
+    get toJsonValueFunction() {
+        return new InlineCallable(code `(value) => ${this.partialType.toJsonValueFunction.unannotatedUsage}(value.${this.runtimeClass.partialPropertyName})`, {
+            type: code `${this.reusables.snippets.ToJsonValueFunction}<${this.expression}, ${this.jsonValueType.expression}>`,
+        });
+    }
     get toRdfResourceValueTypes() {
         return this.partialType.toRdfResourceValueTypes;
     }
@@ -160,6 +160,19 @@ export class AbstractLazyType extends AbstractType {
         caseBlocks.push(code `default: ${variables.resolvedObjectDiscriminatedUnion} satisfies never; throw new Error("unrecognized type");`);
         return code `switch (${variables.resolvedObjectDiscriminatedUnion}.${resolvedObjectDiscriminatedUnionType.discriminatedType.unsafeCoerce().discriminantProperty.name}) { ${joinCode(caseBlocks)} }`;
     }
+    resolverFunctionExpression({ variables, }) {
+        if (!this.configuration.features.has("ObjectSet")) {
+            return code `${this.reusables.snippets.missingResolver}`;
+        }
+        return code `\
+(partial, resolverOptions) => {
+  const objectSet = ${variables.factoryFunctionOptions}?.objectSet;
+  if (!objectSet) {
+    return ${this.reusables.snippets.missingResolver}();
+  }
+  return ${this.objectSetResolveExpression({ variables: { objectSet: code `objectSet`, partial: code `partial`, resolverOptions: code `resolverOptions` } })};
+}`;
+    }
 }
 __decorate([
     Memoize()

package/dist/generators/ts/LazyOptionType.d.ts

@@ -5,7 +5,7 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class LazyOptionType extends AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>> {
     protected readonly partialItemType: AbstractLazyType.ItemTypeConstraint;
     protected readonly resolveItemType: AbstractLazyType.ItemTypeConstraint;
-    readonly graphqlArgs: AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>["graphqlArgs"];
+    readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazyOption";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
     protected get runtimeClass(): {
@@ -13,11 +13,9 @@ export declare class LazyOptionType extends AbstractLazyType<OptionType<Abstract
         partialPropertyName: string;
         rawName: Code;
     };
-    protected objectSetResolverFunctionExpressions({ variables, }: {
-        variables: {
-            objectSet: Code;
-        };
-    }): Code;
-    graphqlResolveExpression({ variables, }: Parameters<AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>["graphqlResolveExpression"]>[0]): Code;
+    protected objectSetResolveExpression({ variables, }: Parameters<Super["objectSetResolveExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
 }
+type Super = AbstractLazyType<OptionType<AbstractLazyType.ItemTypeConstraint>, OptionType<AbstractLazyType.ItemTypeConstraint>>;
+export {};
 //# sourceMappingURL=LazyOptionType.d.ts.map

package/dist/generators/ts/LazyOptionType.js

@@ -53,8 +53,8 @@ ${this.reusables.snippets.convertToLazyOption}<
             rawName: code `${this.reusables.snippets.LazyOption}`,
         };
     }
-    objectSetResolverFunctionExpressions({ variables, }) {
-        return code `(partial, options) => ${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), options)`;
+    objectSetResolveExpression({ variables, }) {
+        return code `${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(${variables.partial}.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), ${variables.resolverOptions})`;
     }
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce().extractNullable())`;

package/dist/generators/ts/LazySetType.d.ts

@@ -8,11 +8,7 @@ export declare class LazySetType extends AbstractLazyType<SetType<AbstractLazyTy
     readonly graphqlArgs: Super["graphqlArgs"];
     readonly kind = "LazySet";
     get conversionFunction(): Maybe<AbstractLazyType.ConversionFunction>;
-    protected objectSetResolverFunctionExpressions({ variables, }: {
-        variables: {
-            objectSet: Code;
-        };
-    }): Code;
+    protected objectSetResolveExpression({ variables, }: Parameters<Super["objectSetResolveExpression"]>[0]): Code;
     protected get runtimeClass(): {
         name: Code;
         partialPropertyName: string;

package/dist/generators/ts/LazySetType.js

@@ -52,8 +52,8 @@ ${this.reusables.snippets.convertToLazySet}<
             ],
         });
     }
-    objectSetResolverFunctionExpressions({ variables, }) {
-        return code `(partials, options) => ${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers: partials.map(partial => partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}()), ...options })`;
+    objectSetResolveExpression({ variables, }) {
+        return code `${variables.objectSet}.${this.resolveType.itemType.objectSetMethodNames.objects}({ identifiers: ${variables.partial}.map(partial => partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}()), ...${variables.resolverOptions} })`;
     }
     get runtimeClass() {
         return {

package/dist/generators/ts/LazyType.d.ts

@@ -13,11 +13,7 @@ export declare class LazyType extends AbstractLazyType<AbstractLazyType.ItemType
         rawName: Code;
     };
     graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
-    protected objectSetResolverFunctionExpressions({ variables, }: {
-        variables: {
-            objectSet: Code;
-        };
-    }): Code;
+    protected objectSetResolveExpression({ variables, }: Parameters<Super["objectSetResolveExpression"]>[0]): Code;
 }
 type Super = AbstractLazyType<AbstractLazyType.ItemTypeConstraint, AbstractLazyType.ItemTypeConstraint>;
 export {};

package/dist/generators/ts/LazyType.js

@@ -47,8 +47,8 @@ ${this.reusables.snippets.convertToLazy}<
     graphqlResolveExpression({ variables, }) {
         return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
     }
-    objectSetResolverFunctionExpressions({ variables, }) {
-        return code `(partial, options) => ${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(partial.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), options)`;
+    objectSetResolveExpression({ variables, }) {
+        return code `${variables.objectSet}.${this.resolveItemType.objectSetMethodNames.object}(${variables.partial}.${this.partialItemType.identifierProperty.unsafeCoerce().name}(), ${variables.resolverOptions})`;
     }
 }
 __decorate([

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.95",
+    "@shaclmate/shacl-ast": "4.0.96",
     "@rdfjs/types": "~2.0.1",
     "@rdfx/collection": "0.0.59",
     "@rdfx/curie": "0.0.59",
@@ -972,5 +972,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.95"
+  "version": "4.0.96"
 }