@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,400 +1,320 @@
-import { Scope, StructureKind, } from "ts-morph";
+import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { snippets } from "./snippets.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const objectTypeType = code `\
+{
+  ${syntheticNamePrefix}filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
+  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet }) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}fromRdfTypes: readonly ${imports.NamedNode}[]
+}`;
+    const parameters = {
+        query: `query?: ${syntheticNamePrefix}ObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
+    };
     const typeParameters = {
-        ObjectT: {
-            constraint: "{ readonly $identifier: ObjectIdentifierT }",
-            name: "ObjectT",
-        },
-        ObjectIdentifierT: {
-            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
-            name: "ObjectIdentifierT",
-        },
+        ObjectT: code `ObjectT extends { readonly $identifier: ObjectIdentifierT }`,
+        ObjectFilterT: code `ObjectFilterT`,
+        ObjectIdentifierT: code `ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}`,
     };
-    const fromRdfFunctionType = `(resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>`;
-    const objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfTypes: readonly rdfjs.NamedNode[] }`;
-    const reusableMethodDeclarations = [];
-    if (objectTypes.length > 0) {
-        const parameters = {
-            objectType: {
-                name: "objectType",
-                type: objectTypeType,
-            },
-            query: {
-                hasQuestionToken: true,
-                name: "query",
-                type: `${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
-            },
-        };
-        reusableMethodDeclarations.push({
-            kind: StructureKind.Method,
-            name: `${syntheticNamePrefix}objectIdentifiersSync`,
-            parameters: [parameters.objectType, parameters.query],
-            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>`,
-            scope: Scope.Protected,
-            statements: [
-                `\
-return this.${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectType.name}, ${parameters.query.name}).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));`,
-            ],
-            typeParameters: [
-                typeParameters.ObjectT,
-                typeParameters.ObjectIdentifierT,
-            ],
-        }, {
-            kind: StructureKind.Method,
-            name: `${syntheticNamePrefix}objectsSync`,
-            parameters: [parameters.objectType, parameters.query],
-            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>`,
-            scope: Scope.Protected,
-            statements: [
-                `\
-const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
-if (limit <= 0) { return purify.Either.of([]); }
+    return code `\
+export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticNamePrefix}ObjectSet {
+  protected readonly ${syntheticNamePrefix}graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+  readonly #dataset: ${imports.DatasetCore} | (() => ${imports.DatasetCore});
 
-let offset = query?.offset ?? 0;
-if (offset < 0) { offset = 0; }
+  constructor(dataset: ${imports.DatasetCore} | (() => ${imports.DatasetCore}), options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+    this.#dataset = dataset;
+    this.${syntheticNamePrefix}graph = options?.graph;
+  }
 
-if (query?.where) {
-  // Assign identifiers in each case block so the compiler will catch missing cases.
-  let identifiers: rdfjsResource.Resource.Identifier[];
-  switch (query.where.type) {
-    case "identifiers": {
-      identifiers = query.where.identifiers.slice(offset, offset + limit);
-      break;
+  protected ${syntheticNamePrefix}dataset(): DatasetCore {
+    if (typeof this.#dataset === "object") {
+      return this.#dataset;
     }
-    case "triple-objects": {
-      let identifierI = 0;
-      identifiers = [];
-      for (const quad of this.resourceSet.dataset.match(query.where.subject, query.where.predicate, null)) {
-        if (quad.object.termType === "BlankNode" || quad.object.termType === "NamedNode") {
-          if (++identifierI >= offset) {
-            identifiers.push(quad.object);
-            if (identifiers.length === limit) {
-              break;
+    return this.#dataset();
+  }
+
+  protected ${syntheticNamePrefix}resourceSet(): ${imports.ResourceSet} {
+    return new ${imports.ResourceSet}(this.${syntheticNamePrefix}dataset(), { dataFactory: ${imports.dataFactory} });
+  }
+
+  ${joinCode([
+        ...[...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
+            if (!objectType.features.has("rdf")) {
+                return Object.values(unsupportedObjectSetMethodDeclarations({
+                    objectType,
+                }));
             }
-          }
-        } else {
-          return purify.Left(new Error(\`subject=\${query.where.subject.value} predicate=\${query.where.predicate.value} pattern matches non-identifier (\${quad.object.termType}) triple\`));
+            const methodSignatures = objectSetMethodSignatures({ objectType });
+            const delegatingMethods = [
+                // object
+                code `\
+async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
+  return this.${methodSignatures.object.name}Sync(identifier);
+}`,
+                // objectSync
+                code `\
+${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${objectType.name}> {
+  return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier] }).map(objects => objects[0]);
+}`,
+                // objectCount
+                code `\
+async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
+  return this.${methodSignatures.objectCount.name}Sync(query);
+}`,
+                // objectCountSync
+                code `\
+${methodSignatures.objectCount.name}Sync(${methodSignatures.objectCount.parameters}): ${imports.Either}<Error, number> {
+  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.length);
+}`,
+                // objectIdentifiers
+                code `\
+async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
+  return this.${methodSignatures.objectIdentifiers.name}Sync(query);
+}`,
+                // objectIdentifiersSync
+                code `\
+${methodSignatures.objectIdentifiers.name}Sync(${methodSignatures.objectIdentifiers.parameters}): ${imports.Either}<Error, readonly ${objectType.identifierTypeAlias}[]> {
+  return this.${methodSignatures.objects.name}Sync(query).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));
+}`,
+                // objects
+                code `\
+async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
+  return this.${methodSignatures.objects.name}Sync(query);
+}`,
+                // objectsSync has per-object type logic, not just forwarding
+            ];
+            const runtimeObjectType = (filterFunction, objectType) => {
+                const fromRdfTypes = objectType.fromRdfTypeVariable
+                    .toList()
+                    .concat(objectType.descendantFromRdfTypeVariables);
+                return code `{ ${syntheticNamePrefix}filter: ${filterFunction}, ${syntheticNamePrefix}fromRdf: ${objectType.staticModuleName}.${syntheticNamePrefix}fromRdf, ${syntheticNamePrefix}fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+            };
+            switch (objectType.kind) {
+                case "ObjectType": {
+                    return delegatingMethods.concat(code `\
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${objectType.name}[]> {
+  return this.${syntheticNamePrefix}objectsSync<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>(${runtimeObjectType(objectType.filterFunction, objectType)}, query);
+}`);
+                }
+                case "ObjectUnionType":
+                    return delegatingMethods.concat(code `\
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${objectType.name}[]> {
+  return this.${syntheticNamePrefix}objectUnionsSync<${objectType.name}, ${objectType.filterType}, ${objectType.identifierTypeAlias}>([
+    ${joinCode(objectType.memberTypes
+                        .filter((memberType) => !memberType.abstract)
+                        .map((memberType) => runtimeObjectType(objectType.filterFunction, memberType)), { on: ", " })}
+  ], query);
+}`);
+                default:
+                    objectType;
+                    return [];
+            }
+        }),
+        ...(objectTypes.length > 0
+            ? [
+                code `\
+protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(objectType: ${objectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+  const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
+
+  const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+  if (limit <= 0) { return ${imports.Right}([]); }
+
+  let offset = query?.offset ?? 0;
+  if (offset < 0) { offset = 0; }
+
+  let resources: { object?: ObjectT, resource: ${imports.Resource} }[];
+  const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
+  let sortResources: boolean;
+  if (query?.identifiers) {
+    resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
+    sortResources = false;
+  } else if (objectType.${syntheticNamePrefix}fromRdfTypes.length > 0) {
+    const identifierSet = new ${snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+      for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
+        if (!identifierSet.has(resource.identifier)) {
+          identifierSet.add(resource.identifier);
+          resources.push({ resource });
         }
       }
-      break;
     }
-  }
-
-  const objects: ${typeParameters.ObjectT.name}[] = [];
-  for (const identifier of identifiers) {
-    const either = objectType.${syntheticNamePrefix}fromRdf(this.resourceSet.resource(identifier), { objectSet: this });
-    if (either.isLeft()) {
-      return either;
-    }
-    objects.push(either.unsafeCoerce());
-  }
-  return purify.Either.of(objects);
-}
+  } else {
+    const identifierSet = new ${snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const quad of resourceSet.dataset) {
+      if (graph && !quad.graph.equals(graph)) {
+        continue;
+      }
 
-if (objectType.${syntheticNamePrefix}fromRdfTypes.length === 0) {
-  return purify.Either.of([]);
-}
+      switch (quad.subject.termType) {
+        case "BlankNode":
+        case "NamedNode":
+          break;
+        default:
+          continue;
+      }
 
-const resources: rdfjsResource.Resource[] = [];
-for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
-  for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
-    if (!resources.some(existingResource => existingResource.identifier.equals(resource.identifier))) {
-      resources.push(resource);
+      if (identifierSet.has(quad.subject)) {
+        continue;
+      }
+      identifierSet.add(quad.subject);
+      const resource = resourceSet.resource(quad.subject);
+      // Eagerly eliminate the majority of resources that won't match the object type
+      objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this }).ifRight(object => {
+        resources.push({ object, resource });
+      });
     }
   }
-}
-// Sort resources by identifier so limit and offset are deterministic
-resources.sort((left, right) => left.identifier.value.localeCompare(right.identifier.value));
 
-const objects: ${typeParameters.ObjectT.name}[] = [];
-let objectI = 0;
-for (const resource of resources) {
-  const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
-  if (either.isLeft()) {
-    return either;
-  }
-  if (objectI++ >= offset) {
-     objects.push(either.unsafeCoerce());
-     if (objects.length === limit) {
-      return purify.Either.of(objects);
-     }
+  if (sortResources) {
+    // Sort resources by identifier so limit and offset are deterministic
+    resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
   }
-}
-return purify.Either.of(objects);
-`,
-            ],
-            typeParameters: [
-                typeParameters.ObjectT,
-                typeParameters.ObjectIdentifierT,
-            ],
-        }, {
-            kind: StructureKind.Method,
-            name: `${syntheticNamePrefix}objectsCountSync`,
-            parameters: [parameters.objectType, parameters.query],
-            returnType: "purify.Either<Error, number>",
-            scope: Scope.Protected,
-            statements: [
-                `return this.${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectType.name}, ${parameters.query.name}).map(objects => objects.length);`,
-            ],
-            typeParameters: [
-                typeParameters.ObjectT,
-                typeParameters.ObjectIdentifierT,
-            ],
-        });
-    }
-    if (objectUnionTypes.length > 0) {
-        const parameters = {
-            objectTypes: {
-                name: "objectTypes",
-                type: `readonly ${objectTypeType}[]`,
-            },
-            query: {
-                hasQuestionToken: true,
-                name: "query",
-                type: `${syntheticNamePrefix}ObjectSet.Query<${typeParameters.ObjectIdentifierT.name}>`,
-            },
-        };
-        reusableMethodDeclarations.push({
-            kind: StructureKind.Method,
-            name: `${syntheticNamePrefix}objectUnionIdentifiersSync`,
-            parameters: [parameters.objectTypes, parameters.query],
-            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectIdentifierT.name}[]>`,
-            scope: Scope.Protected,
-            statements: [
-                `return this.${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectTypes.name}, ${parameters.query.name}).map(objects => objects.map(object => object.${syntheticNamePrefix}identifier));`,
-            ],
-            typeParameters: [
-                typeParameters.ObjectT,
-                typeParameters.ObjectIdentifierT,
-            ],
-        }, {
-            kind: StructureKind.Method,
-            name: `${syntheticNamePrefix}objectUnionsSync`,
-            parameters: [parameters.objectTypes, parameters.query],
-            returnType: `purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>`,
-            scope: Scope.Protected,
-            statements: [
-                `\
-const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
-if (limit <= 0) { return purify.Either.of([]); }
 
-let offset = query?.offset ?? 0;
-if (offset < 0) { offset = 0; }
+  let objectI = 0;
+  const objects: ObjectT[] = [];
+  for (let { object, resource } of resources) {
+    if (!object) {
+      const objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+      if (objectEither.isLeft()) {
+        return objectEither;
+      }
+      object = objectEither.unsafeCoerce();
+    }
 
-if (query?.where) {
-  // Assign identifiers in each case block so the compiler will catch missing cases.
-  let identifiers: rdfjsResource.Resource.Identifier[];
-  switch (query.where.type) {
-    case "identifiers": {
-      identifiers = query.where.identifiers.slice(offset, offset + limit);
-      break;
+    if (query?.filter && !objectType.${syntheticNamePrefix}filter(query.filter, object)) {
+      continue;
     }
-    case "triple-objects": {
-      let identifierI = 0;
-      identifiers = [];
-      for (const quad of this.resourceSet.dataset.match(query.where.subject, query.where.predicate, null)) {
-        if (quad.object.termType === "BlankNode" || quad.object.termType === "NamedNode") {
-          if (++identifierI >= offset) {
-            identifiers.push(quad.object);
-            if (identifiers.length === limit) {
-              break;
-            }
-          }
-        } else {
-          return purify.Left(new Error(\`subject=\${query.where.subject.value} predicate=\${query.where.predicate.value} pattern matches non-identifier (\${quad.object.termType}) triple\`));
-        }
+
+    if (objectI++ >= offset) {
+      objects.push(object);
+      if (objects.length === limit) {
+        return ${imports.Right}(objects);
       }
-      break;
     }
   }
+  return ${imports.Right}(objects);
+  }`,
+            ]
+            : []),
+        ...(objectUnionTypes.length > 0
+            ? [
+                code `\
+protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(objectTypes: readonly ${objectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+  const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
+
+  const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
+  if (limit <= 0) { return ${imports.Right}([]); }
 
-  const objects: ${typeParameters.ObjectT.name}[] = [];
-  for (const identifier of identifiers) {
-    const resource = this.resourceSet.resource(identifier);
-    const lefts: purify.Either<Error, ${typeParameters.ObjectT.name}>[] = [];
+  let offset = query?.offset ?? 0;
+  if (offset < 0) { offset = 0; }
+
+  let resources: { object?: ObjectT, objectType?: ${objectTypeType}, resource: ${imports.Resource} }[];
+  const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
+  let sortResources: boolean;
+  if (query?.identifiers) {
+    resources = query.identifiers.map(identifier => ({ resource: resourceSet.resource(identifier) }));
+    sortResources = false;
+  } else if (objectTypes.every(objectType => objectType.${syntheticNamePrefix}fromRdfTypes.length > 0)) {
+    const identifierSet = new ${snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
     for (const objectType of objectTypes) {
-      const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
-      if (either.isRight()) {
-        objects.push(either.unsafeCoerce());
-        break;
+      for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
+        for (const resource of resourceSet.instancesOf(fromRdfType, { graph })) {
+          if (!identifierSet.has(resource.identifier)) {
+            identifierSet.add(resource.identifier);
+            resources.push({ objectType, resource });
+          }
+        }
       }
-      lefts.push(either);
     }
-    // Doesn't appear to belong to any of the known object types, just assume the first
-    if (lefts.length === objectTypes.length) {
-      return lefts[0] as unknown as purify.Either<Error, readonly ${typeParameters.ObjectT.name}[]>;
+  } else {
+    const identifierSet = new ${snippets.IdentifierSet}();
+    resources = [];
+    sortResources = true;
+    for (const quad of resourceSet.dataset) {
+      if (graph && !quad.graph.equals(graph)) {
+        continue;
+      }
+    
+      switch (quad.subject.termType) {
+        case "BlankNode":
+        case "NamedNode":
+          break;
+        default:
+          continue;
+      }
+
+      if (identifierSet.has(quad.subject)) {
+        continue;
+      }
+      identifierSet.add(quad.subject);
+      // Eagerly eliminate the majority of resources that won't match the object types
+      const resource = resourceSet.resource(quad.subject);
+      for (const objectType of objectTypes) {
+        if (objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this }).ifRight(object => {
+          resources.push({ object, objectType, resource });
+        }).isRight()) {
+          break;
+        }
+      }
     }
   }
-  return purify.Either.of(objects);
-}
 
-const resources: { objectType: ${objectTypeType}, resource: rdfjsResource.Resource }[] = [];
-for (const objectType of objectTypes) {
-  if (objectType.${syntheticNamePrefix}fromRdfTypes.length === 0) {
-    continue;
+  if (sortResources) {
+    // Sort resources by identifier so limit and offset are deterministic
+    resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
   }
 
-  for (const fromRdfType of objectType.${syntheticNamePrefix}fromRdfTypes) {
-    for (const resource of this.resourceSet.instancesOf(fromRdfType)) {
-      if (!resources.some(({ resource: existingResource }) => existingResource.identifier.equals(resource.identifier))) {
-        resources.push({ objectType, resource });
+  let objectI = 0;
+  const objects: ObjectT[] = [];
+  for (let { object, objectType, resource } of resources) {
+    if (!object) {
+      let objectEither: ${imports.Either}<Error, ObjectT>;
+      if (objectType) {
+        objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+      } else {
+        objectEither = ${imports.Left}(new Error("no object types"));
+        for (const tryObjectType of objectTypes) {
+          objectEither = tryObjectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+          if (objectEither.isRight()) {
+            objectType = tryObjectType;
+            break;
+          }
+        }
       }
+      if (objectEither.isLeft()) {
+        return objectEither;
+      }
+      object = objectEither.unsafeCoerce();
+    }
+    if (!objectType) {
+      throw new Error("objectType should be set here");
     }
-  }
-}
-// Sort resources by identifier so limit and offset are deterministic
-resources.sort((left, right) => left.resource.identifier.value.localeCompare(right.resource.identifier.value));
 
-let objectI = 0;
-const objects: ${typeParameters.ObjectT.name}[] = [];
-for (const { objectType, resource } of resources) {
-  const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
-  if (either.isLeft()) {
-    return either;
-  }
-  if (objectI++ >= offset) {
-    objects.push(either.unsafeCoerce());
-    if (objects.length === limit) {
-      return purify.Either.of(objects);
+    if (query?.filter && !objectType.${syntheticNamePrefix}filter(query.filter, object)) {
+      continue;
     }
-  }
-}
-return purify.Either.of(objects);
-`,
-            ],
-            typeParameters: [
-                typeParameters.ObjectT,
-                typeParameters.ObjectIdentifierT,
-            ],
-        }, {
-            kind: StructureKind.Method,
-            name: `${syntheticNamePrefix}objectUnionsCountSync`,
-            parameters: [parameters.objectTypes, parameters.query],
-            returnType: "purify.Either<Error, number>",
-            statements: [
-                `return this.${syntheticNamePrefix}objectUnionIdentifiersSync<${typeParameters.ObjectT.name}, ${typeParameters.ObjectIdentifierT.name}>(${parameters.objectTypes.name}, ${parameters.query.name}).map(objects => objects.length);`,
-            ],
-            typeParameters: [
-                typeParameters.ObjectT,
-                typeParameters.ObjectIdentifierT,
-            ],
-            scope: Scope.Protected,
-        });
+
+    if (objectI++ >= offset) {
+      objects.push(object);
+      if (objects.length === limit) {
+        return ${imports.Right}(objects);
+      }
     }
-    return {
-        ctors: [
-            {
-                parameters: [
-                    {
-                        name: "{ dataset }",
-                        type: "{ dataset: rdfjs.DatasetCore }",
-                    },
-                ],
-                statements: [
-                    "this.resourceSet = new rdfjsResource.ResourceSet({ dataset })",
-                ],
-            },
-        ],
-        implements: [`${syntheticNamePrefix}ObjectSet`],
-        isExported: true,
-        kind: StructureKind.Class,
-        name: `${syntheticNamePrefix}RdfjsDatasetObjectSet`,
-        methods: [...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
-            if (!objectType.features.has("rdf")) {
-                return unsupportedObjectSetMethodDeclarations({
-                    objectType,
-                });
-            }
-            const methodSignatures = objectSetMethodSignatures({ objectType });
-            let runtimeObjectType;
-            const runtimeObjectType_ = (objectType) => `{ ${syntheticNamePrefix}fromRdf: ${objectType.staticModuleName}.${syntheticNamePrefix}fromRdf, ${syntheticNamePrefix}fromRdfTypes: [${objectType.fromRdfTypeVariable.toList().concat(objectType.descendantFromRdfTypeVariables).join(", ")}] }`;
-            switch (objectType.kind) {
-                case "ObjectType":
-                    runtimeObjectType = runtimeObjectType_(objectType);
-                    break;
-                case "ObjectUnionType":
-                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => runtimeObjectType_(memberType)).join(", ")}]`;
-                    break;
-            }
-            return [
-                {
-                    ...methodSignatures.object,
-                    isAsync: true,
-                    kind: StructureKind.Method,
-                    statements: [
-                        `return this.${methodSignatures.object.name}Sync(identifier);`,
-                    ],
-                },
-                {
-                    ...methodSignatures.object,
-                    kind: StructureKind.Method,
-                    name: `${methodSignatures.object.name}Sync`,
-                    returnType: `purify.Either<Error, ${objectType.name}>`,
-                    statements: [
-                        `return this.${methodSignatures.objects.name}Sync({ where: { identifiers: [identifier], type: "identifiers" } }).map(objects => objects[0]);`,
-                    ],
-                },
-                {
-                    ...methodSignatures.objectIdentifiers,
-                    isAsync: true,
-                    kind: StructureKind.Method,
-                    statements: [
-                        `return this.${methodSignatures.objectIdentifiers.name}Sync(query);`,
-                    ],
-                },
-                {
-                    ...methodSignatures.objectIdentifiers,
-                    kind: StructureKind.Method,
-                    name: `${methodSignatures.objectIdentifiers.name}Sync`,
-                    returnType: `purify.Either<Error, readonly ${objectType.identifierTypeAlias}[]>`,
-                    statements: `return this.${syntheticNamePrefix}object${objectType.kind === "ObjectUnionType" ? "Union" : ""}IdentifiersSync<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
-                },
-                {
-                    ...methodSignatures.objects,
-                    isAsync: true,
-                    kind: StructureKind.Method,
-                    statements: [
-                        `return this.${methodSignatures.objects.name}Sync(query);`,
-                    ],
-                },
-                {
-                    ...methodSignatures.objects,
-                    kind: StructureKind.Method,
-                    name: `${methodSignatures.objects.name}Sync`,
-                    returnType: `purify.Either<Error, readonly ${objectType.name}[]>`,
-                    statements: [
-                        `return this.${syntheticNamePrefix}object${objectType.kind === "ObjectUnionType" ? "Union" : ""}sSync<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
-                    ],
-                },
-                {
-                    ...methodSignatures.objectsCount,
-                    isAsync: true,
-                    kind: StructureKind.Method,
-                    statements: [
-                        `return this.${methodSignatures.objectsCount.name}Sync(query);`,
-                    ],
-                },
-                {
-                    ...methodSignatures.objectsCount,
-                    kind: StructureKind.Method,
-                    name: `${methodSignatures.objectsCount.name}Sync`,
-                    returnType: "purify.Either<Error, number>",
-                    statements: [
-                        `return this.${syntheticNamePrefix}object${objectType.kind === "ObjectUnionType" ? "Union" : ""}sCountSync<${objectType.name}, ${objectType.identifierTypeAlias}>(${runtimeObjectType}, query);`,
-                    ],
-                },
-            ];
-        }).concat(reusableMethodDeclarations),
-        properties: [
-            {
-                isReadonly: true,
-                name: "resourceSet",
-                type: "rdfjsResource.ResourceSet",
-            },
-        ],
-    };
+  }
+  return ${imports.Right}(objects);
+}`,
+            ]
+            : []),
+    ], { on: "\n\n" })}
+}`;
 }
 //# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.js.map