@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -0,0 +1,86 @@
+import { Maybe } from "purify-ts";
+import { objectInitializer } from "./objectInitializer.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+function graphqlQueryObjectType({ objectTypes, objectUnionTypes, }) {
+    return `new graphql.GraphQLObjectType<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${objectInitializer([...objectTypes, ...objectUnionTypes].reduce((fields, objectType) => {
+        fields[objectType.objectSetMethodNames.object] = objectInitializer({
+            args: objectInitializer({
+                identifier: objectInitializer({
+                    type: "new graphql.GraphQLNonNull(graphql.GraphQLID)",
+                }),
+            }),
+            resolve: `\
+async (_source, args: { identifier: string }, { objectSet }): Promise<${objectType.name}> => 
+  (await purify.EitherAsync<Error, ${objectType.name}>(async ({ liftEither }) => 
+    liftEither(await objectSet.${objectType.objectSetMethodNames.object}(await liftEither(${objectType.identifierTypeAlias}.fromString(args.identifier))))
+  )).unsafeCoerce()`,
+            type: objectType.graphqlName.toString(),
+        });
+        fields[objectType.objectSetMethodNames.objectIdentifiers] =
+            objectInitializer({
+                args: objectInitializer({
+                    limit: objectInitializer({
+                        type: "graphql.GraphQLInt",
+                    }),
+                    offset: objectInitializer({
+                        type: "graphql.GraphQLInt",
+                    }),
+                }),
+                resolve: `\
+ async (_source, args: { limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly string[]> =>
+  (await objectSet.${objectType.objectSetMethodNames.objectIdentifiers}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined })).unsafeCoerce().map(${objectType.identifierTypeAlias}.toString)`,
+                type: "new graphql.GraphQLNonNull(new graphql.GraphQLList(graphql.GraphQLString))",
+            });
+        fields[objectType.objectSetMethodNames.objects] = objectInitializer({
+            args: objectInitializer({
+                identifiers: objectInitializer({
+                    type: "new graphql.GraphQLList(new graphql.GraphQLNonNull(graphql.GraphQLID))",
+                }),
+                limit: objectInitializer({
+                    type: "graphql.GraphQLInt",
+                }),
+                offset: objectInitializer({
+                    type: "graphql.GraphQLInt",
+                }),
+            }),
+            resolve: `\
+async (_source, args: { identifiers: readonly string[] | null; limit: number | null; offset: number | null; }, { objectSet }): Promise<readonly ${objectType.name}[]> =>
+(await purify.EitherAsync<Error, readonly ${objectType.name}[]>(async ({ liftEither }) => {
+  let where: $ObjectSet.Where<${objectType.identifierTypeAlias}> | undefined;
+  if (args.identifiers) {
+    const identifiers: ${objectType.identifierTypeAlias}[] = [];
+    for (const identifierArg of args.identifiers) {
+      identifiers.push(await liftEither(${objectType.identifierTypeAlias}.fromString(identifierArg)));
+    }
+    where = { identifiers, type: "identifiers" };
+  }
+  return await liftEither(await objectSet.${objectType.objectSetMethodNames.objects}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined, where }));
+})).unsafeCoerce()`,
+            type: `new graphql.GraphQLNonNull(new graphql.GraphQLList(${objectType.graphqlName}))`,
+        });
+        fields[objectType.objectSetMethodNames.objectsCount] =
+            objectInitializer({
+                resolve: `\
+async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${objectType.objectSetMethodNames.objectsCount}()).unsafeCoerce()`,
+                type: "new graphql.GraphQLNonNull(graphql.GraphQLInt)",
+            });
+        return fields;
+    }, {}))} })`;
+}
+export function graphqlSchemaVariableStatement(parameters) {
+    const objectTypes = parameters.objectTypes.filter((objectType) => objectType.features.has("graphql") && !objectType.synthetic);
+    const objectUnionTypes = parameters.objectUnionTypes.filter((objectUnionType) => objectUnionType.features.has("graphql"));
+    if (objectTypes.length === 0) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        isExported: true,
+        declarations: [
+            {
+                name: "graphqlSchema",
+                initializer: `new graphql.GraphQLSchema({ query: ${graphqlQueryObjectType({ objectTypes, objectUnionTypes })} })`,
+            },
+        ],
+    });
+}
+//# sourceMappingURL=graphqlSchemaVariableStatement.js.map

package/dist/generators/ts/objectSetDeclarations.d.ts

@@ -0,0 +1,8 @@
+import type { ClassDeclarationStructure, InterfaceDeclarationStructure, ModuleDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function objectSetDeclarations({ objectUnionTypes, ...parameters }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): readonly (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
+//# sourceMappingURL=objectSetDeclarations.d.ts.map

package/dist/generators/ts/objectSetDeclarations.js

@@ -0,0 +1,59 @@
+import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
+import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
+import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
+export function objectSetDeclarations({ objectUnionTypes, ...parameters }) {
+    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.abstract && !objectType.extern && !objectType.synthetic);
+    let objectTypesWithRdfFeatureCount = 0;
+    let objectTypesWithSparqlFeatureCount = 0;
+    for (const objectType of objectTypes) {
+        if (!objectType.features.has("rdf") && !objectType.features.has("sparql")) {
+            continue;
+        }
+        if (objectType.features.has("rdf")) {
+            objectTypesWithRdfFeatureCount++;
+        }
+        if (objectType.features.has("sparql")) {
+            objectTypesWithSparqlFeatureCount++;
+        }
+    }
+    let objectUnionTypesWithRdfFeatureCount = 0;
+    let objectUnionTypesWithSparqlFeatureCount = 0;
+    for (const objectUnionType of objectUnionTypes) {
+        if (!objectUnionType.features.has("rdf") &&
+            !objectUnionType.features.has("sparql")) {
+            continue;
+        }
+        if (objectUnionType.features.has("rdf")) {
+            objectUnionTypesWithRdfFeatureCount++;
+        }
+        if (objectUnionType.features.has("sparql")) {
+            objectUnionTypesWithSparqlFeatureCount++;
+        }
+    }
+    if (objectTypesWithRdfFeatureCount === 0 &&
+        objectTypesWithSparqlFeatureCount === 0 &&
+        objectUnionTypesWithRdfFeatureCount === 0 &&
+        objectUnionTypesWithSparqlFeatureCount === 0) {
+        return [];
+    }
+    const statements = [
+        ...objectSetInterfaceDeclaration({
+            objectTypes,
+            objectUnionTypes,
+        }),
+    ];
+    if (objectTypesWithRdfFeatureCount > 0) {
+        statements.push(rdfjsDatasetObjectSetClassDeclaration({
+            objectTypes,
+            objectUnionTypes,
+        }));
+    }
+    if (objectTypesWithSparqlFeatureCount > 0) {
+        statements.push(...sparqlObjectSetClassDeclaration({
+            objectTypes,
+            objectUnionTypes,
+        }));
+    }
+    return statements;
+}
+//# sourceMappingURL=objectSetDeclarations.js.map

package/dist/generators/ts/objectSetInterfaceDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type InterfaceDeclarationStructure, type ModuleDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function objectSetInterfaceDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): readonly (InterfaceDeclarationStructure | ModuleDeclarationStructure)[];
+//# sourceMappingURL=objectSetInterfaceDeclaration.d.ts.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -0,0 +1,46 @@
+import { StructureKind, } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function objectSetInterfaceDeclaration({ objectTypes, objectUnionTypes, }) {
+    const typeParameters = {
+        ObjectIdentifierT: {
+            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
+            name: "ObjectIdentifierT",
+        },
+    };
+    return [
+        {
+            isExported: true,
+            kind: StructureKind.Interface,
+            methods: objectTypes
+                .flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })))
+                .concat(objectUnionTypes.flatMap((objectUnionType) => Object.values(objectSetMethodSignatures({ objectType: objectUnionType })))),
+            name: `${syntheticNamePrefix}ObjectSet`,
+        },
+        {
+            isExported: true,
+            kind: StructureKind.Module,
+            name: `${syntheticNamePrefix}ObjectSet`,
+            statements: [
+                {
+                    kind: StructureKind.TypeAlias,
+                    isExported: true,
+                    name: "Query",
+                    type: `{ readonly limit?: number; readonly offset?: number; readonly where?: Where<${typeParameters.ObjectIdentifierT.name}> }`,
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+                {
+                    kind: StructureKind.TypeAlias,
+                    isExported: true,
+                    name: "Where",
+                    type: [
+                        `{ readonly identifiers: readonly ${typeParameters.ObjectIdentifierT.name}[]; readonly type: "identifiers" } `,
+                        `{ readonly predicate: rdfjs.NamedNode; readonly subject: rdfjs.BlankNode | rdfjs.NamedNode; readonly type: "triple-objects" } `,
+                    ].join(" | "),
+                    typeParameters: [typeParameters.ObjectIdentifierT],
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=objectSetInterfaceDeclaration.js.map

package/dist/generators/ts/objectSetMethodSignatures.d.ts

@@ -0,0 +1,11 @@
+import type { MethodSignatureStructure, OptionalKind } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+export declare function objectSetMethodSignatures(parameters: {
+    objectType: {
+        readonly identifierTypeAlias: string;
+        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly name: string;
+    };
+    queryT?: string;
+}): Record<keyof ObjectType.ObjectSetMethodNames, OptionalKind<MethodSignatureStructure>>;
+//# sourceMappingURL=objectSetMethodSignatures.d.ts.map

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -0,0 +1,52 @@
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+export function objectSetMethodSignatures(parameters) {
+    const { objectType } = parameters;
+    const queryT = parameters.queryT ?? `${syntheticNamePrefix}ObjectSet.Query`;
+    const methodNames = objectType.objectSetMethodNames;
+    return {
+        object: {
+            name: methodNames.object,
+            parameters: [
+                {
+                    name: "identifier",
+                    type: objectType.identifierTypeAlias,
+                },
+            ],
+            returnType: `Promise<purify.Either<Error, ${objectType.name}>>`,
+        },
+        objectIdentifiers: {
+            name: methodNames.objectIdentifiers,
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: "query",
+                    type: `${queryT}<${objectType.identifierTypeAlias}>`,
+                },
+            ],
+            returnType: `Promise<purify.Either<Error, readonly ${objectType.identifierTypeAlias}[]>>`,
+        },
+        objects: {
+            name: methodNames.objects,
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: "query",
+                    type: `${queryT}<${objectType.identifierTypeAlias}>`,
+                },
+            ],
+            returnType: `Promise<purify.Either<Error, readonly ${objectType.name}[]>>`,
+        },
+        objectsCount: {
+            name: methodNames.objectsCount,
+            parameters: [
+                {
+                    hasQuestionToken: true,
+                    name: "query",
+                    type: `Pick<${queryT}<${objectType.identifierTypeAlias}>, "where">`,
+                },
+            ],
+            returnType: "Promise<purify.Either<Error, number>>",
+        },
+    };
+}
+//# sourceMappingURL=objectSetMethodSignatures.js.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.d.ts

@@ -0,0 +1,8 @@
+import { type ClassDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "./ObjectType.js";
+import type { ObjectUnionType } from "./ObjectUnionType.js";
+export declare function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }: {
+    objectTypes: readonly ObjectType[];
+    objectUnionTypes: readonly ObjectUnionType[];
+}): ClassDeclarationStructure;
+//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.d.ts.map

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -0,0 +1,393 @@
+import { Scope, StructureKind, } from "ts-morph";
+import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
+export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
+    const typeParameters = {
+        ObjectT: {
+            constraint: "{ readonly $identifier: ObjectIdentifierT }",
+            name: "ObjectT",
+        },
+        ObjectIdentifierT: {
+            constraint: "rdfjs.BlankNode | rdfjs.NamedNode",
+            name: "ObjectIdentifierT",
+        },
+    };
+    const fromRdfFunctionType = `(resource: rdfjsResource.Resource, options: { objectSet: ${syntheticNamePrefix}ObjectSet }) => purify.Either<Error, ${typeParameters.ObjectT.name}>`;
+    const reusableMethodDeclarations = [];
+    if (objectTypes.length > 0) {
+        const parameters = {
+            objectType: {
+                name: "objectType",
+                type: `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`,
+            },
+            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([]); }
+
+let offset = query?.offset ?? 0;
+if (offset < 0) { offset = 0; }
+
+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;
+    }
+    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\`));
+        }
+      }
+      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);
+}
+
+if (!objectType.${syntheticNamePrefix}fromRdfType) {
+  return purify.Either.of([]);
+}
+
+const resources = [...this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)];
+// 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);
+     }
+  }
+}
+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 objectTypeType = `{ ${syntheticNamePrefix}fromRdf: ${fromRdfFunctionType}; ${syntheticNamePrefix}fromRdfType?: rdfjs.NamedNode }`;
+        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; }
+
+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;
+    }
+    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\`));
+        }
+      }
+      break;
+    }
+  }
+
+  const objects: ${typeParameters.ObjectT.name}[] = [];
+  for (const identifier of identifiers) {
+    const resource = this.resourceSet.resource(identifier);
+    const lefts: purify.Either<Error, ${typeParameters.ObjectT.name}>[] = [];
+    for (const objectType of objectTypes) {
+      const either = objectType.${syntheticNamePrefix}fromRdf(resource, { objectSet: this });
+      if (either.isRight()) {
+        objects.push(either.unsafeCoerce());
+        break;
+      }
+      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}[]>;
+    }
+  }
+  return purify.Either.of(objects);
+}
+
+const resources: { objectType: ${objectTypeType}, resource: rdfjsResource.Resource }[] = [];
+for (const objectType of objectTypes) {
+  if (!objectType.${syntheticNamePrefix}fromRdfType) {
+    continue;
+  }
+
+  for (const resource of this.resourceSet.instancesOf(objectType.${syntheticNamePrefix}fromRdfType)) {
+    resources.push({ objectType, resource });
+  }
+}
+
+// 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);
+    }
+  }
+}
+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,
+        });
+    }
+    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;
+            switch (objectType.kind) {
+                case "ObjectType":
+                    runtimeObjectType = objectType.fromRdfType.isJust()
+                        ? `${objectType.staticModuleName}`
+                        : `{ ...${objectType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`;
+                    break;
+                case "ObjectUnionType":
+                    runtimeObjectType = `[${objectType.memberTypes.map((memberType) => memberType.fromRdfType.isJust()
+                        ? `${memberType.staticModuleName}`
+                        : `{ ...${memberType.staticModuleName}, ${syntheticNamePrefix}fromRdfType: undefined }`)}]`;
+                    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",
+            },
+        ],
+    };
+}
+//# sourceMappingURL=rdfjsDatasetObjectSetClassDeclaration.js.map