@shaclmate/compiler 4.0.96 → 4.0.97

package/dist/generators/ts/ObjectDiscriminatedUnionType.d.ts

@@ -1,22 +1,22 @@
 import type { Maybe } from "purify-ts";
-import { ObjectDiscriminatedUnionType_schemaExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.js";
 import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { Callable } from "./Callable.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
+import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType<ObjectType> {
-    protected schemaExpression: typeof ObjectDiscriminatedUnionType_schemaExpression;
+export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType<ObjectDiscriminatedUnionType.MemberType> {
     readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly kind = "ObjectDiscriminatedUnion";
     constructor({ identifierType, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
-    } & ConstructorParameters<typeof AbstractDiscriminatedUnionType<ObjectType>>[0]);
+    } & ConstructorParameters<typeof AbstractDiscriminatedUnionType<ObjectDiscriminatedUnionType.MemberType>>[0]);
     get focusSparqlConstructTriplesFunction(): Callable;
     get focusSparqlWherePatternsFunction(): Callable;
     get fromRdfResourceFunction(): Callable;
+    get fromRdfTypeVariables(): readonly Code[];
     get identifierTypeAlias(): Code;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get sparqlConstructQueryFunction(): Callable;
@@ -26,4 +26,7 @@ export declare class ObjectDiscriminatedUnionType extends AbstractDiscriminatedU
     protected get inlineExpression(): Code;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
 }
+export declare namespace ObjectDiscriminatedUnionType {
+    type MemberType = ObjectDiscriminatedUnionType | ObjectIntersectionType | ObjectType;
+}
 //# sourceMappingURL=ObjectDiscriminatedUnionType.d.ts.map

package/dist/generators/ts/ObjectDiscriminatedUnionType.js

@@ -10,7 +10,6 @@ import { ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction } from
 import { ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.js";
 import { ObjectDiscriminatedUnionType_fromRdfResourceFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunction.js";
 import { ObjectDiscriminatedUnionType_graphqlTypeExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeExpression.js";
-import { ObjectDiscriminatedUnionType_schemaExpression } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.js";
 import { ObjectDiscriminatedUnionType_toRdfResourceFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunction.js";
 import { ObjectDiscriminatedUnionType_typeGuardFunction } from "./_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunction.js";
 import { ObjectType_identifierTypeDeclarations } from "./_ObjectType/ObjectType_identifierTypeDeclarations.js";
@@ -21,7 +20,6 @@ import { AbstractDiscriminatedUnionType } from "./AbstractDiscriminatedUnionType
 import { DeclaredCallable } from "./DeclaredCallable.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType {
-    schemaExpression = ObjectDiscriminatedUnionType_schemaExpression;
     identifierType;
     kind = "ObjectDiscriminatedUnion";
     constructor({ identifierType, ...superParameters }) {
@@ -37,6 +35,21 @@ export class ObjectDiscriminatedUnionType extends AbstractDiscriminatedUnionType
     get fromRdfResourceFunction() {
         return ObjectDiscriminatedUnionType_fromRdfResourceFunction.call(this);
     }
+    get fromRdfTypeVariables() {
+        return this.members.flatMap((member) => {
+            switch (member.type.kind) {
+                case "Object":
+                    return member.type.fromRdfTypeVariable.toList();
+                case "ObjectDiscriminatedUnion":
+                    return member.type.fromRdfTypeVariables;
+                case "ObjectIntersection":
+                    return [];
+                default:
+                    member.type;
+                    throw new RangeError("should never reach this point");
+            }
+        });
+    }
     get identifierTypeAlias() {
         return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
     }
@@ -121,6 +134,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "fromRdfResourceFunction", null);
+__decorate([
+    Memoize()
+], ObjectDiscriminatedUnionType.prototype, "fromRdfTypeVariables", null);
 __decorate([
     Memoize()
 ], ObjectDiscriminatedUnionType.prototype, "identifierTypeAlias", null);

package/dist/generators/ts/ObjectIntersectionType.d.ts

@@ -10,7 +10,7 @@ import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { ObjectType } from "./ObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectIntersectionType extends AbstractIntersectionType<ObjectType> {
+export declare class ObjectIntersectionType extends AbstractIntersectionType<ObjectIntersectionType.MemberType> {
     protected fromJsonObjectFunctionExpression: typeof ObjectIntersectionType_fromJsonObjectFunctionExpression;
     protected fromJsonObjectFunctionType: typeof ObjectIntersectionType_fromJsonObjectFunctionType;
     protected fromRdfResourceValuesFunctionExpression: typeof ObjectIntersectionType_fromRdfResourceValuesFunctionExpression;
@@ -22,7 +22,7 @@ export declare class ObjectIntersectionType extends AbstractIntersectionType<Obj
     readonly kind = "ObjectIntersection";
     constructor({ identifierType, ...superParameters }: {
         identifierType: BlankNodeType | IdentifierType | IriType;
-    } & ConstructorParameters<typeof AbstractIntersectionType<ObjectType>>[0]);
+    } & ConstructorParameters<typeof AbstractIntersectionType<ObjectIntersectionType.MemberType>>[0]);
     get _fromRdfResourceFunction(): Callable;
     get _toRdfResourceFunction(): Callable;
     get createFunction(): Callable;
@@ -31,8 +31,8 @@ export declare class ObjectIntersectionType extends AbstractIntersectionType<Obj
     get focusSparqlWherePatternsFunction(): Callable;
     get fromRdfResourceFunction(): Callable;
     get identifierTypeAlias(): Code;
-    get jsonObjectType(): AbstractIntersectionType<ObjectType>["jsonObjectType"];
-    get jsonValueType(): AbstractIntersectionType<ObjectType>["jsonValueType"];
+    get jsonObjectType(): AbstractIntersectionType<ObjectIntersectionType.MemberType>["jsonObjectType"];
+    get jsonValueType(): AbstractIntersectionType<ObjectIntersectionType.MemberType>["jsonValueType"];
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
     get sparqlConstructQueryFunction(): Callable;
     get sparqlConstructQueryStringFunction(): Callable;
@@ -41,4 +41,7 @@ export declare class ObjectIntersectionType extends AbstractIntersectionType<Obj
     protected get createUnsafeFunction(): Callable;
     protected staticModuleDeclarations(name: string): Record<string, Code>;
 }
+export declare namespace ObjectIntersectionType {
+    type MemberType = ObjectIntersectionType | ObjectType;
+}
 //# sourceMappingURL=ObjectIntersectionType.d.ts.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -4,10 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, joinCode } from "./ts-poet-wrapper.js";
 export class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
     get declaration() {
         const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
@@ -87,30 +86,42 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 }`,
                     // objectsSync has per-object type logic, not just forwarding
                 ];
-                const runtimeObjectType = (filterFunction, namedObjectType) => {
-                    return code `{ filter: ${filterFunction.annotatedUsage}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
+                const runtimeObjectType = (namedObjectType, options) => {
+                    let fromRdfTypeVariables;
+                    switch (namedObjectType.kind) {
+                        case "Object":
+                            fromRdfTypeVariables =
+                                namedObjectType.fromRdfTypeVariable.toList();
+                            break;
+                        case "ObjectDiscriminatedUnion":
+                            fromRdfTypeVariables = namedObjectType.fromRdfTypeVariables;
+                            break;
+                        case "ObjectIntersection":
+                            fromRdfTypeVariables = [];
+                            break;
+                    }
+                    return code `{ filter: ${(options?.filterFunction ?? namedObjectType.filterFunction).annotatedUsage}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${arrayOf(...fromRdfTypeVariables)} }`;
                 };
                 switch (namedObjectType.kind) {
                     case "Object": {
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
-  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType)}, query);
 }`);
                     }
                     case "ObjectDiscriminatedUnion":
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
   return this.#objectDiscriminatedUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
-    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
+    ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(member.type, {
+                            filterFunction: namedObjectType.filterFunction,
+                        })), { on: ", " })}
   ], query);
 }`);
                     case "ObjectIntersection":
                         return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
-  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, {
-                            expression: namedObjectType.expression,
-                            fromRdfTypeVariable: Maybe.empty(),
-                        })}, query);
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType)}, query);
 }`);
                     default:
                         namedObjectType;

package/dist/generators/ts/TypeFactory.js

@@ -86,23 +86,12 @@ export class TypeFactory {
                 return cachedType;
             }
         }
-        const objectDiscriminatedUnionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType));
+        const objectDiscriminatedUnionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType).unsafeCoerce());
         const objectDiscriminatedUnionTypeName = astType.name.map((name) => this.tsName(name));
         const objectDiscriminatedUnionType = new ObjectDiscriminatedUnionType({
             ...this.constructorParameters,
             comment: astType.comment,
-            identifierProperty: astType.isStructDiscriminatedUnionType() &&
-                astType.members.every((member) => {
-                    switch (member.type.kind) {
-                        case "DiscriminatedUnion":
-                            return member.type.members.every((member) => member.type.identifierField.isJust());
-                        case "Struct":
-                            return member.type.identifierField.isJust();
-                        default:
-                            member.type;
-                            throw new Error("should never reach this point");
-                    }
-                })
+            identifierProperty: ast.StructCompoundType.hasIdentifierField(astType)
                 ? Maybe.of(new ObjectType.IdentifierProperty({
                     ...this.constructorParameters,
                     name: `${this.configuration.syntheticNamePrefix}identifier`,
@@ -112,10 +101,16 @@ export class TypeFactory {
                 : Maybe.empty(),
             identifierType: objectDiscriminatedUnionIdentifierType,
             label: astType.label,
-            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
-                discriminantValue: Maybe.empty(),
-                type: this.createObjectType(astStructType),
-            })),
+            members: astType.members.map((member) => {
+                const type = this.createType(member.type);
+                invariant(type.kind === "ObjectDiscriminatedUnion" ||
+                    type.kind === "ObjectIntersection" ||
+                    type.kind === "Object", type.kind);
+                return {
+                    discriminantValue: Maybe.empty(),
+                    type: type,
+                };
+            }),
             name: objectDiscriminatedUnionTypeName,
             recursive: astType.recursive,
             shapeIdentifier: astType.shapeIdentifier,
@@ -132,23 +127,12 @@ export class TypeFactory {
                 return cachedType;
             }
         }
-        const objectIntersectionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType));
+        const objectIntersectionIdentifierType = this.createIdentifierType(ast.StructCompoundType.identifierType(astType).unsafeCoerce());
         const objectIntersectionTypeName = astType.name.map((name) => this.tsName(name));
         const objectIntersectionType = new ObjectIntersectionType({
             ...this.constructorParameters,
             comment: astType.comment,
-            identifierProperty: astType.isStructIntersectionType() &&
-                astType.members.every((member) => {
-                    switch (member.type.kind) {
-                        case "Intersection":
-                            return member.type.members.every((member) => member.type.identifierField.isJust());
-                        case "Struct":
-                            return member.type.identifierField.isJust();
-                        default:
-                            member.type;
-                            throw new Error("should never reach this point");
-                    }
-                })
+            identifierProperty: ast.StructCompoundType.hasIdentifierField(astType)
                 ? Maybe.of(new ObjectType.IdentifierProperty({
                     ...this.constructorParameters,
                     name: `${this.configuration.syntheticNamePrefix}identifier`,
@@ -158,9 +142,11 @@ export class TypeFactory {
                 : Maybe.empty(),
             identifierType: objectIntersectionIdentifierType,
             label: astType.label,
-            members: ast.StructCompoundType.memberStructTypes(astType).map((astStructType) => ({
-                type: this.createObjectType(astStructType),
-            })),
+            members: astType.members.map((member) => {
+                const type = this.createType(member.type);
+                invariant(type.kind === "ObjectIntersection" || type.kind === "Object", type.kind);
+                return { type };
+            }),
             name: objectIntersectionTypeName,
             recursive: astType.recursive,
             shapeIdentifier: astType.shapeIdentifier,