@shaclmate/compiler 3.0.3 → 4.0.0

package/dist/generators/ts/LazyObjectType.d.ts

@@ -0,0 +1,14 @@
+import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class LazyObjectType extends AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint> {
+    readonly graphqlArgs: Super["graphqlArgs"];
+    readonly kind = "LazyObjectType";
+    constructor({ partialType, resolveType, ...superParameters }: Omit<ConstructorParameters<typeof AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>>[0], "runtimeClass">);
+    get conversions(): readonly AbstractLazyObjectType.Conversion[];
+    fromJsonExpression(parameters: Parameters<Super["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression(parameters: Parameters<Super["fromRdfExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<Super["graphqlResolveExpression"]>[0]): Code;
+}
+type Super = AbstractLazyObjectType<AbstractLazyObjectType.ObjectTypeConstraint, AbstractLazyObjectType.ObjectTypeConstraint>;
+export {};
+//# sourceMappingURL=LazyObjectType.d.ts.map

package/dist/generators/ts/LazyObjectType.js

@@ -0,0 +1,59 @@
+import { Maybe } from "purify-ts";
+import { AbstractLazyObjectType } from "./AbstractLazyObjectType.js";
+import { imports } from "./imports.js";
+import { snippets } from "./snippets.js";
+import { code } from "./ts-poet-wrapper.js";
+export class LazyObjectType extends AbstractLazyObjectType {
+    graphqlArgs = Maybe.empty();
+    kind = "LazyObjectType";
+    constructor({ partialType, resolveType, ...superParameters }) {
+        super({
+            ...superParameters,
+            partialType,
+            resolveType,
+            runtimeClass: {
+                name: code `${snippets.LazyObject}<${resolveType.identifierTypeAlias}, ${partialType.name}, ${resolveType.name}>`,
+                partialPropertyName: "partial",
+                rawName: code `${snippets.LazyObject}`,
+            },
+        });
+    }
+    get conversions() {
+        const conversions = super.conversions.concat();
+        if (this.partialType.kind === "ObjectType") {
+            conversions.push({
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.newExpression({ parameters: value })}, resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                // Don't check instanceof value since the ObjectType may be an interface
+                // Rely on the fact that this will be the last type check on an object
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: this.resolveType.name,
+                sourceTypeof: "object",
+            });
+        }
+        else if (this.resolveType.kind === "ObjectUnionType" &&
+            this.partialType.kind === "ObjectUnionType" &&
+            this.resolveType.memberTypes.length ===
+                this.partialType.memberTypes.length) {
+            conversions.push({
+                conversionExpression: (value) => code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ((object: ${this.resolveType.name}) => { ${this.resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType: this.resolveType, partialObjectUnionType: this.partialType, variables: { resolvedObjectUnion: code `object` } })} })(${value}), resolver: async () => ${imports.Right}(${value} as ${this.resolveType.name}) })`,
+                // Don't check instanceof value since the ObjectUnionType may be an interface
+                // Rely on the fact that this will be the last type check on an object
+                sourceTypeCheckExpression: (value) => code `typeof ${value} === "object"`,
+                sourceTypeName: this.resolveType.name,
+                sourceTypeof: "object",
+            });
+        }
+        return conversions;
+    }
+    fromJsonExpression(parameters) {
+        return code `new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}: ${this.partialType.fromJsonExpression(parameters)}, resolver: (identifier) => Promise.resolve(${imports.Left}(new Error(\`unable to resolve identifier \${${imports.Resource}.Identifier.toString(identifier)} deserialized from JSON\`))) })`;
+    }
+    fromRdfExpression(parameters) {
+        const { variables } = parameters;
+        return code `${this.partialType.fromRdfExpression(parameters)}.map(values => values.map(${this.runtimeClass.partialPropertyName} => new ${this.runtimeClass.name}({ ${this.runtimeClass.partialPropertyName}, resolver: (identifier) => ${variables.objectSet}.${this.resolveType.objectSetMethodNames.object}(identifier) })))`;
+    }
+    graphqlResolveExpression({ variables, }) {
+        return code `${variables.value}.resolve().then(either => either.unsafeCoerce())`;
+    }
+}
+//# sourceMappingURL=LazyObjectType.js.map

package/dist/generators/ts/ListType.d.ts

@@ -1,41 +1,43 @@
 import type { NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
+import type { Maybe } from "purify-ts";
 import type { IdentifierMintingStrategy } from "../../enums/index.js";
-import { Import } from "./Import.js";
-import { Type } from "./Type.js";
-export declare class ListType extends Type {
-    private readonly _mutable;
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { BigDecimalType } from "./BigDecimalType.js";
+import type { BigIntType } from "./BigIntType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { BooleanType } from "./BooleanType.js";
+import type { DateTimeType } from "./DateTimeType.js";
+import type { DateType } from "./DateType.js";
+import type { FloatType } from "./FloatType.js";
+import type { IdentifierType } from "./IdentifierType.js";
+import type { IntType } from "./IntType.js";
+import type { IriType } from "./IriType.js";
+import type { LiteralType } from "./LiteralType.js";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { StringType } from "./StringType.js";
+import type { TermType } from "./TermType.js";
+import type { Type } from "./Type.js";
+import { type Code } from "./ts-poet-wrapper.js";
+import type { UnionType } from "./UnionType.js";
+export declare class ListType<ItemTypeT extends ListType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     private readonly identifierMintingStrategy;
     private readonly identifierNodeKind;
     private readonly toRdfTypes;
-    readonly itemType: Type;
     readonly kind = "ListType";
-    readonly typeof = "object";
-    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, }: {
-        identifierNodeKind: ListType["identifierNodeKind"];
-        itemType: Type;
+    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
+        identifierNodeKind: ListType<ItemTypeT>["identifierNodeKind"];
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
-        mutable: boolean;
         toRdfTypes: readonly NamedNode[];
-    });
-    get conversions(): readonly Type.Conversion[];
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get equalsFunction(): string;
-    get graphqlName(): Type.GraphqlName;
-    get jsonName(): Type.JsonName;
-    get mutable(): boolean;
-    get name(): string;
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    graphqlResolveExpression({ variables, }: Parameters<Type["graphqlResolveExpression"]>[0]): string;
-    hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
-    jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(parameters: Parameters<Type["useImports"]>[0]): readonly Import[];
+    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
+    fromRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfExpression"]>[0]): Code;
+    jsonType(): AbstractCollectionType.JsonType;
+    toRdfExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfExpression"]>[0]): Code;
+}
+export declare namespace ListType {
+    type ItemType = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | FloatType | IdentifierType | IntType | IriType | LiteralType | ObjectType | ObjectUnionType | StringType | TermType | UnionType;
+    function isItemType(type: Type): type is ItemType;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/dist/generators/ts/ListType.js

@@ -4,345 +4,150 @@ 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 { rdf } from "@tpluscode/rdf-ns-builders";
 import { Memoize } from "typescript-memoize";
-import { Import } from "./Import.js";
-import { SnippetDeclarations } from "./SnippetDeclarations.js";
-import { Type } from "./Type.js";
-import { objectInitializer } from "./objectInitializer.js";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import { imports } from "./imports.js";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export class ListType extends Type {
-    _mutable;
+import { snippets } from "./snippets.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+export class ListType extends AbstractCollectionType {
     identifierMintingStrategy;
     identifierNodeKind;
     toRdfTypes;
-    itemType;
     kind = "ListType";
-    typeof = "object";
-    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, }) {
-        super();
+    constructor({ identifierNodeKind, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
+        super(superParameters);
         this.identifierNodeKind = identifierNodeKind;
-        this.itemType = itemType;
         this.identifierMintingStrategy = identifierMintingStrategy.orDefault(identifierNodeKind === "BlankNode" ? "blankNode" : "sha256");
-        this._mutable = mutable;
         this.toRdfTypes = toRdfTypes;
     }
-    get conversions() {
-        return [
-            {
-                // Defensive copy
-                conversionExpression: (value) => `${value}${this.mutable ? ".concat()" : ""}`,
-                // Array.isArray doesn't narrow correctly
-                // sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
-                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-                sourceTypeName: this.name,
-            },
-        ];
+    get sparqlConstructTriplesFunction() {
+        return code `${snippets.listSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlConstructTriplesFunction})`;
     }
-    get discriminatorProperty() {
-        return Maybe.empty();
-    }
-    get equalsFunction() {
-        return `((left, right) => ${syntheticNamePrefix}arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
-    }
-    get graphqlName() {
-        return new Type.GraphqlName(`new graphql.GraphQLList(${this.itemType.graphqlName})`);
-    }
-    get jsonName() {
-        return new Type.JsonName(`readonly (${this.itemType.jsonName})[]`);
-    }
-    get mutable() {
-        return this._mutable || this.itemType.mutable;
-    }
-    get name() {
-        return `${this._mutable ? "" : "readonly "}${this.itemType.name}[]`;
-    }
-    fromJsonExpression({ variables, }) {
-        return `${variables.value}.map(item => (${this.itemType.fromJsonExpression({ variables: { value: "item" } })}))`;
+    get sparqlWherePatternsFunction() {
+        return code `${snippets.listSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.sparqlWherePatternsFunction})`;
     }
     fromRdfExpression({ variables, }) {
-        return [
+        return joinCode([
             variables.resourceValues,
-            "chain(values => values.chainMap(value => value.toList()))", // Resource.Values<Resource.Value> to Resource.Values<Resource.Value[]>
-            `chain(valueLists =>
+            code `chain(values => values.chainMap(value => value.toList(${{ graph: variables.graph }})))`, // Resource.Values<Resource.Value> to Resource.Values<Resource.Values>
+            code `chain(valueLists =>
         valueLists.chainMap(
           valueList => ${this.itemType.fromRdfExpression({
                 variables: {
                     ...variables,
-                    resourceValues: `purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(rdfjsResource.Resource.Values.fromArray({ objects: valueList, predicate: ${variables.predicate}, subject: ${variables.resource} }))`,
+                    resourceValues: code `${imports.Right}(${imports.Resource}.Values.fromArray({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, values: valueList.toArray() }))`,
                 },
             })}
-      ))`, // Resource.Values<Resource.Value[]> to Resource.Values<item type arrays>
-            `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
-        ].join(".");
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    hashStatements({ depth, variables, }) {
-        return [
-            `for (const item${depth} of ${variables.value}) { ${this.itemType.hashStatements({ depth: depth + 1, variables: { ...variables, value: `item${depth}` } }).join("\n")} }`,
-        ];
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
-    jsonZodSchema(parameters) {
-        return `${this.itemType.jsonZodSchema(parameters)}.array()`;
-    }
-    snippetDeclarations(parameters) {
-        const snippetDeclarations = this.itemType
-            .snippetDeclarations(parameters)
-            .concat();
-        if (parameters.features.has("equals")) {
-            snippetDeclarations.push(SnippetDeclarations.arrayEquals);
-        }
-        return snippetDeclarations;
-    }
-    sparqlConstructTemplateTriples(parameters) {
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlConstructTemplateTriples(parameters);
-            case "subject": {
-                const { variables } = parameters;
-                const triples = [];
-                const listVariable = variables.subject;
-                const variable = (suffix) => `dataFactory.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
-                const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
-                {
-                    // ?list rdf:first ?item0
-                    const item0Variable = variable("Item0");
-                    triples.push(objectInitializer({
-                        subject: listVariable,
-                        predicate: rdfjsTermExpression(rdf.first),
-                        object: item0Variable,
-                    }), ...this.itemType.sparqlConstructTemplateTriples({
-                        allowIgnoreRdfType: true,
-                        context: "subject",
-                        variables: {
-                            subject: item0Variable,
-                            variablePrefix: variablePrefix("Item0"),
-                        },
-                    }));
-                }
-                {
-                    // ?list rdf:rest ?rest0
-                    const rest0Variable = variable("Rest0");
-                    triples.push(objectInitializer({
-                        subject: listVariable,
-                        predicate: rdfjsTermExpression(rdf.rest),
-                        object: rest0Variable,
-                    }));
-                }
-                // Don't do ?list rdf:rest+ ?restN in CONSTRUCT
-                const restNVariable = variable("RestN");
-                {
-                    // ?rest rdf:first ?itemN
-                    const itemNVariable = variable("ItemN");
-                    triples.push(objectInitializer({
-                        subject: restNVariable,
-                        predicate: rdfjsTermExpression(rdf.first),
-                        object: itemNVariable,
-                    }), ...this.itemType.sparqlConstructTemplateTriples({
-                        allowIgnoreRdfType: true,
-                        context: "subject",
-                        variables: {
-                            subject: itemNVariable,
-                            variablePrefix: variablePrefix("ItemN"),
-                        },
-                    }));
-                }
-                // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
-                triples.push(objectInitializer({
-                    subject: restNVariable,
-                    predicate: rdfjsTermExpression(rdf.rest),
-                    object: variable("RestNBasic"),
-                }));
-                return triples;
-            }
-        }
+      ))`, // Resource.Values<Resource.Values> to Resource.Values<item type arrays>
+            code `map(valueLists => valueLists.map(valueList => valueList.toArray()${this.mutable ? ".concat()" : ""}))`, // Convert inner Resource.Values to arrays
+        ], { on: "." });
     }
-    sparqlWherePatterns(parameters) {
-        // Need to handle two cases:
-        // (1) (?s, ?p, ?list) where ?list binds to rdf:nil
-        // (2) (?s, ?p, ?list) (?list, rdf:first, "element") (?list, rdf:rest, rdf:nil) etc. where list binds to the head of a list
-        // Case (2) is case (1) with OPTIONAL graph patterns to handle actual list elements.
-        switch (parameters.context) {
-            case "object":
-                return super.sparqlWherePatterns(parameters);
-            case "subject": {
-                const { variables } = parameters;
-                const patterns = [];
-                const listVariable = variables.subject;
-                const variable = (suffix) => `dataFactory.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
-                const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
-                {
-                    // ?list rdf:first ?item0
-                    const item0Variable = variable("Item0");
-                    patterns.push(`{ type: "bgp", triples: [${objectInitializer({
-                        subject: listVariable,
-                        predicate: rdfjsTermExpression(rdf.first),
-                        object: item0Variable,
-                    })}] }`, ...this.itemType.sparqlWherePatterns({
-                        allowIgnoreRdfType: true,
-                        context: "subject",
-                        variables: {
-                            preferredLanguages: parameters.variables.preferredLanguages,
-                            subject: item0Variable,
-                            variablePrefix: variablePrefix("Item0"),
-                        },
-                    }));
-                }
-                {
-                    // ?list rdf:rest ?rest0
-                    const rest0Variable = variable("Rest0");
-                    patterns.push(`{ type: "bgp", triples: [${objectInitializer({
-                        subject: listVariable,
-                        predicate: rdfjsTermExpression(rdf.rest),
-                        object: rest0Variable,
-                    })}] }`);
-                }
-                const optionalPatterns = [];
-                const restNVariable = variable("RestN");
-                // ?list rdf:rest+ ?restN
-                optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
-                    subject: listVariable,
-                    predicate: `{ type: "path", pathType: "*", items: [${rdfjsTermExpression(rdf.rest)}] }`,
-                    object: restNVariable,
-                })}] }`);
-                {
-                    // ?rest rdf:first ?itemN
-                    const itemNVariable = variable("ItemN");
-                    optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
-                        subject: restNVariable,
-                        predicate: rdfjsTermExpression(rdf.first),
-                        object: itemNVariable,
-                    })}] }`, ...this.itemType.sparqlWherePatterns({
-                        allowIgnoreRdfType: true,
-                        context: "subject",
-                        variables: {
-                            preferredLanguages: parameters.variables.preferredLanguages,
-                            subject: itemNVariable,
-                            variablePrefix: variablePrefix("ItemN"),
-                        },
-                    }));
-                }
-                // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
-                optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
-                    subject: restNVariable,
-                    predicate: rdfjsTermExpression(rdf.rest),
-                    object: variable("RestNBasic"),
-                })}] }`);
-                patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
-                // Having an optional around everything handles the rdf:nil case
-                return [`{ type: "optional", patterns: [${patterns.join(", ")}] }`];
-            }
-        }
-    }
-    toJsonExpression({ variables, }) {
-        let expression = variables.value;
-        const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: "item" },
-        });
-        if (itemFromJsonExpression !== "item") {
-            expression = `${expression}.map(item => (${itemFromJsonExpression}))`;
-        }
-        return `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: "item" } })}))`;
+    jsonType() {
+        return new AbstractCollectionType.JsonType(code `readonly (${this.itemType.jsonType().name})[]`);
     }
     toRdfExpression({ variables, }) {
         let listIdentifier;
-        let mutableResourceTypeName;
-        let resourceSetMethodName;
+        let resourceTypeName;
         let subListIdentifier;
         switch (this.identifierNodeKind) {
             case "BlankNode": {
-                listIdentifier = subListIdentifier = "dataFactory.blankNode()";
-                mutableResourceTypeName = "rdfjsResource.MutableResource";
-                resourceSetMethodName = "mutableResource";
+                listIdentifier =
+                    subListIdentifier = code `${imports.dataFactory}.blankNode()`;
+                resourceTypeName = code `${imports.Resource}<${imports.BlankNode}>`;
                 break;
             }
-            case "NamedNode": {
+            case "IRI": {
                 switch (this.identifierMintingStrategy) {
                     case "blankNode":
                         throw new RangeError(this.identifierMintingStrategy);
                     case "sha256":
-                        listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
+                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
         (hasher, item) => {
-          ${this.itemType.hashStatements({ depth: 0, variables: { hasher: "hasher", value: "item" } }).join("\n")}
+          ${joinCode(this.itemType.hashStatements({ depth: 0, variables: { hasher: code `hasher`, value: code `item` } }).concat())}
           return hasher;
         },
-        sha256.create(),
+        ${imports.sha256}.create(),
       )}\`)`;
                         break;
                     case "uuidv4":
-                        listIdentifier =
-                            "dataFactory.namedNode(`urn:shaclmate:list:${uuid.v4()}`)";
+                        listIdentifier = code `${imports.dataFactory}.namedNode(\`urn:shaclmate:list:\${${imports.uuid}.v4()}\`)`;
                         break;
                 }
-                mutableResourceTypeName =
-                    "rdfjsResource.MutableResource<rdfjs.NamedNode>";
-                resourceSetMethodName = "mutableNamedResource";
-                subListIdentifier =
-                    "dataFactory.namedNode(`${listResource.identifier.value}:${itemIndex}`)";
+                resourceTypeName = code `${imports.Resource}<${imports.NamedNode}>`;
+                subListIdentifier = code `${imports.dataFactory}.namedNode(\`\${listResource.identifier.value}:\${itemIndex}\`)`;
                 break;
             }
         }
-        return `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
+        return code `[${variables.value}.length > 0 ? ${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${subListIdentifier}, ${objectInitializer({
-            mutateGraph: variables.mutateGraph,
-        })});
-      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier);
+      const newSubListResource = ${variables.resourceSet}.resource(${subListIdentifier});
+      currentSubListResource!.add(${rdfjsTermExpression(rdf.rest)}, newSubListResource.identifier, ${variables.graph});
       currentSubListResource = newSubListResource;
     }
     
-    ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
-        
-    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ...${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: rdfjsTermExpression(rdf.first), resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
+    ${joinCode(this.toRdfTypes.map((rdfType) => code `currentSubListResource.add(${rdfjsTermExpression(rdf.type)}, ${imports.dataFactory}.namedNode("${rdfType.value}"), ${variables.graph})`))}
+    
+    currentSubListResource.add(${rdfjsTermExpression(rdf.first)}, ${this.itemType.toRdfExpression({ variables: { graph: variables.graph, propertyPath: rdfjsTermExpression(rdf.first), resource: code `currentSubListResource`, resourceSet: variables.resourceSet, value: code `item` } })}, ${variables.graph});
 
     if (itemIndex + 1 === list.length) {
-      currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)});
+      currentSubListResource.add(${rdfjsTermExpression(rdf.rest)}, ${rdfjsTermExpression(rdf.nil)}, ${variables.graph});
     }
     
     return { currentSubListResource, listResource };
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.${resourceSetMethodName}(${listIdentifier}, ${objectInitializer({
-            mutateGraph: variables.mutateGraph,
-        })}),
+    listResource: resourceSet.resource(${listIdentifier}),
   } as {
-    currentSubListResource: ${mutableResourceTypeName} | null;
-    listResource: ${mutableResourceTypeName};
+    currentSubListResource: ${resourceTypeName} | null;
+    listResource: ${resourceTypeName};
   },
 ).listResource.identifier : ${rdfjsTermExpression(rdf.nil)}]`;
     }
-    useImports(parameters) {
-        const imports = this.itemType.useImports(parameters).concat();
-        if (parameters.features.has("hash") &&
-            this.identifierNodeKind === "NamedNode") {
-            imports.push(Import.SHA256);
-        }
-        return imports;
-    }
 }
 __decorate([
     Memoize()
-], ListType.prototype, "conversions", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "equalsFunction", null);
+], ListType.prototype, "sparqlConstructTriplesFunction", null);
 __decorate([
     Memoize()
-], ListType.prototype, "graphqlName", null);
+], ListType.prototype, "sparqlWherePatternsFunction", null);
 __decorate([
     Memoize()
-], ListType.prototype, "jsonName", null);
-__decorate([
-    Memoize()
-], ListType.prototype, "name", null);
+], ListType.prototype, "jsonType", null);
+(function (ListType) {
+    function isItemType(type) {
+        switch (type.kind) {
+            case "BigDecimalType":
+            case "BigIntType":
+            case "BlankNodeType":
+            case "BooleanType":
+            case "DateTimeType":
+            case "DateType":
+            case "FloatType":
+            case "IdentifierType":
+            case "IriType":
+            case "IntType":
+            case "LiteralType":
+            case "ObjectType":
+            case "ObjectUnionType":
+            case "StringType":
+            case "TermType":
+            case "UnionType":
+                return true;
+            case "DefaultValueType":
+            case "LazyObjectOptionType":
+            case "LazyObjectSetType":
+            case "LazyObjectType":
+            case "ListType":
+            case "OptionType":
+            case "SetType":
+                return false;
+        }
+    }
+    ListType.isItemType = isItemType;
+})(ListType || (ListType = {}));
 //# sourceMappingURL=ListType.js.map

package/dist/generators/ts/LiteralType.d.ts

@@ -1,20 +1,18 @@
-import type { Literal } from "@rdfjs/types";
-import { TermType } from "./TermType.js";
-import { Type } from "./Type.js";
-export declare class LiteralType extends TermType<Literal, Literal> {
-    private readonly languageIn;
-    constructor({ languageIn, ...superParameters }: {
-        languageIn: readonly string[];
-    } & Omit<ConstructorParameters<typeof TermType<Literal, Literal>>[0], "nodeKinds">);
-    get jsonName(): Type.JsonName;
-    fromJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["fromJsonExpression"]>[0]): string;
-    protected fromRdfExpressionChain({ variables, }: Parameters<TermType<Literal>["fromRdfExpressionChain"]>[0]): ReturnType<TermType<Literal>["fromRdfExpressionChain"]>;
-    hashStatements({ depth, variables, }: Parameters<TermType<Literal, Literal>["hashStatements"]>[0]): readonly string[];
-    jsonZodSchema({ variables, }: Parameters<TermType<Literal, Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal, Literal>["jsonZodSchema"]>;
-    snippetDeclarations(parameters: Parameters<Type["snippetDeclarations"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0] & {
-        ignoreLiteralLanguage?: boolean;
-    }): readonly string[];
-    toJsonExpression({ variables, }: Parameters<TermType<Literal, Literal>["toJsonExpression"]>[0]): string;
+import { AbstractLiteralType } from "./AbstractLiteralType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+export declare class LiteralType extends AbstractLiteralType {
+    readonly filterFunction: Code;
+    readonly filterType: Code;
+    readonly kind = "LiteralType";
+    readonly name: Code;
+    readonly schemaType: Code;
+    readonly sparqlWherePatternsFunction: Code;
+    get graphqlType(): AbstractLiteralType.GraphqlType;
+    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression(_parameters: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
+    hashStatements({ depth, variables, }: Parameters<AbstractLiteralType["hashStatements"]>[0]): readonly Code[];
+    jsonType(parameters?: Parameters<AbstractLiteralType["jsonType"]>[0]): AbstractLiteralType.JsonType;
+    jsonZodSchema({ includeDiscriminantProperty, }: Parameters<AbstractLiteralType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ includeDiscriminantProperty, variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=LiteralType.d.ts.map