@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/_snippets/snippets_termFilterSparqlPatterns.js

@@ -0,0 +1,98 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
+import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
+import { snippets_TermFilter } from "./snippets_TermFilter.js";
+export const snippets_termFilterSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}termFilterSparqlPatterns`, code `\
+function ${syntheticNamePrefix}termFilterSparqlPatterns({ filter, valueVariable }: { filter?: ${snippets_TermFilter}; valueVariable: ${imports.Variable} }): readonly ${snippets_SparqlFilterPattern}[] {
+  if (!filter) {
+    return [];
+  }
+
+  const filterPatterns: ${snippets_SparqlFilterPattern}[] = [];
+
+  if (
+    filter.datatypeIn !== undefined &&
+    filter.datatypeIn.length > 0
+  ) {
+    filterPatterns.push({
+      expression: {
+        type: "operation",
+        operator: "in",
+        args: [
+          { args: [valueVariable], operator: "datatype", type: "operation" },
+          filter.datatypeIn.concat(),
+        ],
+      },
+      lift: true,
+      type: "filter",
+    });
+  }
+
+  if (filter.in !== undefined && filter.in.length > 0) {
+    filterPatterns.push(${snippets_sparqlValueInPattern}({ lift: true, valueVariable, valueIn: filter.in }));
+  }
+
+  if (
+    filter.languageIn !== undefined &&
+    filter.languageIn.length > 0
+  ) {
+    filterPatterns.push({
+      expression: {
+        type: "operation",
+        operator: "in",
+        args: [{ args: [valueVariable], operator: "lang", type: "operation" }, filter.languageIn.map(value => ${imports.dataFactory}.literal(value))]
+      },
+      lift: true,
+      type: "filter",
+    });
+  }
+
+  if (filter.typeIn !== undefined) {
+    const typeInExpressions = filter.typeIn
+      .map((inType) => {
+        switch (inType) {
+          case "BlankNode":
+            return "isBlank";
+          case "Literal":
+            return "isLiteral";
+          case "NamedNode":
+            return "isIRI";
+          default:
+            inType satisfies never;
+            throw new RangeError(inType);
+        }
+      })
+      .map((operator) => ({
+        type: "operation" as const,
+        operator,
+        args: [valueVariable],
+      }));
+
+    switch (typeInExpressions.length) {
+      case 0:
+        break;
+      case 1:
+        filterPatterns.push({
+          expression: typeInExpressions[0],
+          lift: true,
+          type: "filter",
+        });
+        break;
+      default:
+        filterPatterns.push({
+          expression: {
+            type: "operation",
+            operator: "||",
+            args: typeInExpressions,
+          },
+          lift: true,
+          type: "filter",
+        });
+    }
+  }
+
+  return filterPatterns;
+}`);
+//# sourceMappingURL=snippets_termFilterSparqlPatterns.js.map

package/dist/generators/ts/_snippets/snippets_termSchemaSparqlPatterns.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_termSchemaSparqlPatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_termSchemaSparqlPatterns.d.ts.map

package/dist/generators/ts/_snippets/snippets_termSchemaSparqlPatterns.js

@@ -0,0 +1,29 @@
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlFilterPattern } from "./snippets_SparqlFilterPattern.js";
+import { snippets_SparqlPattern } from "./snippets_SparqlPattern.js";
+import { snippets_sparqlValueInPattern } from "./snippets_sparqlValueInPattern.js";
+export const snippets_termSchemaSparqlPatterns = conditionalOutput(`${syntheticNamePrefix}termSchemaSparqlPatterns`, code `\
+function ${syntheticNamePrefix}termSchemaSparqlPatterns({
+  filterPatterns,
+  propertyPatterns,
+  schema,
+  valueVariable
+}: {
+  filterPatterns: readonly ${snippets_SparqlFilterPattern}[],
+  propertyPatterns: readonly ${snippets_SparqlPattern}[];
+  schema: Readonly<{
+    in?: readonly (bigint | boolean | Date | string | number | ${imports.Literal} | ${imports.NamedNode})[];
+  }>,
+  valueVariable: ${imports.Variable};
+}): readonly ${snippets_SparqlPattern}[] {
+  let patterns: ${snippets_SparqlPattern}[] = propertyPatterns.concat();
+
+  if (schema.in && schema.in.length > 0) {
+    patterns.push(${snippets_sparqlValueInPattern}({ valueVariable, valueIn: schema.in }));
+  }
+
+  return patterns.concat(filterPatterns);
+}`);
+//# sourceMappingURL=snippets_termSchemaSparqlPatterns.js.map

package/dist/generators/ts/_snippets/snippets_termSparqlWherePatterns.d.ts

@@ -0,0 +1,2 @@
+export declare const snippets_termSparqlWherePatterns: import("ts-poet/build/ConditionalOutput.js").ConditionalOutput;
+//# sourceMappingURL=snippets_termSparqlWherePatterns.d.ts.map

package/dist/generators/ts/_snippets/snippets_termSparqlWherePatterns.js

@@ -0,0 +1,11 @@
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatternsFunction.js";
+import { snippets_TermFilter } from "./snippets_TermFilter.js";
+import { snippets_TermSchema } from "./snippets_TermSchema.js";
+import { snippets_termFilterSparqlPatterns } from "./snippets_termFilterSparqlPatterns.js";
+import { snippets_termSchemaSparqlPatterns } from "./snippets_termSchemaSparqlPatterns.js";
+export const snippets_termSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}termSparqlWherePatterns`, code `\
+const ${syntheticNamePrefix}termSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<${snippets_TermFilter}, ${snippets_TermSchema}> =
+  (parameters) => ${snippets_termSchemaSparqlPatterns}({ filterPatterns: ${snippets_termFilterSparqlPatterns}(parameters), ...parameters })`);
+//# sourceMappingURL=snippets_termSparqlWherePatterns.js.map

package/dist/generators/ts/codeEquals.d.ts

@@ -0,0 +1,3 @@
+import type { Code } from "./ts-poet-wrapper.js";
+export declare function codeEquals(left: Code | string, right: Code | string): boolean;
+//# sourceMappingURL=codeEquals.d.ts.map

package/dist/generators/ts/codeEquals.js

@@ -0,0 +1,7 @@
+function codeToString(code) {
+    return typeof code === "string" ? code : code.toString({});
+}
+export function codeEquals(left, right) {
+    return codeToString(left) === codeToString(right);
+}
+//# sourceMappingURL=codeEquals.js.map

package/dist/generators/ts/graphqlSchemaVariableStatement.d.ts

@@ -1,9 +1,9 @@
 import { Maybe } from "purify-ts";
-import type { OptionalKind, VariableStatementStructure } from "ts-morph";
 import type { ObjectType } from "./ObjectType.js";
 import type { ObjectUnionType } from "./ObjectUnionType.js";
+import { type Code } from "./ts-poet-wrapper.js";
 export declare function graphqlSchemaVariableStatement(parameters: {
     objectTypes: readonly ObjectType[];
     objectUnionTypes: ObjectUnionType[];
-}): Maybe<OptionalKind<VariableStatementStructure>>;
+}): Maybe<Code>;
 //# sourceMappingURL=graphqlSchemaVariableStatement.d.ts.map

package/dist/generators/ts/graphqlSchemaVariableStatement.js

@@ -1,71 +1,73 @@
 import { Maybe } from "purify-ts";
-import { objectInitializer } from "./objectInitializer.js";
+import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code } from "./ts-poet-wrapper.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: `\
+    return code `new ${imports.GraphQLObjectType}<null, { objectSet: ${syntheticNamePrefix}ObjectSet }>({ name: "Query", fields: ${[
+        ...objectTypes,
+        ...objectUnionTypes,
+    ].reduce((fields, objectType) => {
+        fields[objectType.objectSetMethodNames.object] = {
+            args: {
+                identifier: {
+                    type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLID})`,
+                },
+            },
+            resolve: code `\
 async (_source, args: { identifier: string }, { objectSet }): Promise<${objectType.name}> => 
-  (await purify.EitherAsync<Error, ${objectType.name}>(async ({ liftEither }) => 
+  (await ${imports.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: `\
+            type: objectType.graphqlType.name,
+        };
+        fields[objectType.objectSetMethodNames.objectIdentifiers] = {
+            args: {
+                limit: {
+                    type: code `${imports.GraphQLInt}`,
+                },
+                offset: {
+                    type: code `${imports.GraphQLInt}`,
+                },
+            },
+            resolve: code `\
  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: `\
+            type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${imports.GraphQLString}))`,
+        };
+        fields[objectType.objectSetMethodNames.objects] = {
+            args: {
+                identifiers: {
+                    type: code `new ${imports.GraphQLList}(new ${imports.GraphQLNonNull}(${imports.GraphQLID}))`,
+                },
+                limit: {
+                    type: code `${imports.GraphQLInt}`,
+                },
+                offset: {
+                    type: code `${imports.GraphQLInt}`,
+                },
+            },
+            resolve: code `\
 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;
+(await ${imports.EitherAsync}<Error, readonly ${objectType.name}[]>(async ({ liftEither }) => {
+  let filter: ${objectType.filterType} | 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" };
+    filter = { ${syntheticNamePrefix}identifier: { in: identifiers } };
   }
-  return await liftEither(await objectSet.${objectType.objectSetMethodNames.objects}({ limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined, where }));
+  return await liftEither(await objectSet.${objectType.objectSetMethodNames.objects}({ filter, limit: args.limit !== null ? args.limit : undefined, offset: args.offset !== null ? args.offset : undefined }));
 })).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)",
-            });
+            type: code `new ${imports.GraphQLNonNull}(new ${imports.GraphQLList}(${objectType.graphqlType.name}))`,
+        };
+        fields[objectType.objectSetMethodNames.objectCount] = {
+            resolve: code `\
+async (_source, _args, { objectSet }): Promise<number> => (await objectSet.${objectType.objectSetMethodNames.objectCount}()).unsafeCoerce()`,
+            type: code `new ${imports.GraphQLNonNull}(${imports.GraphQLInt})`,
+        };
         return fields;
-    }, {}))} })`;
+    }, {})} })`;
 }
 export function graphqlSchemaVariableStatement(parameters) {
     const objectTypes = parameters.objectTypes.filter((objectType) => objectType.features.has("graphql") && !objectType.synthetic);
@@ -73,14 +75,8 @@ export function graphqlSchemaVariableStatement(parameters) {
     if (objectTypes.length === 0) {
         return Maybe.empty();
     }
-    return Maybe.of({
-        isExported: true,
-        declarations: [
-            {
-                name: "graphqlSchema",
-                initializer: `new graphql.GraphQLSchema({ query: ${graphqlQueryObjectType({ objectTypes, objectUnionTypes })} })`,
-            },
-        ],
-    });
+    return Maybe.of(code `\
+export const graphqlSchema = new ${imports.GraphQLSchema}({ query: ${graphqlQueryObjectType({ objectTypes, objectUnionTypes })} });
+`);
 }
 //# sourceMappingURL=graphqlSchemaVariableStatement.js.map

package/dist/generators/ts/imports.d.ts

@@ -0,0 +1,40 @@
+export declare const imports: {
+    readonly BigDecimal: import("ts-poet/build/Import.js").Import;
+    readonly BlankNode: import("ts-poet/build/Import.js").Import;
+    readonly dataFactory: import("ts-poet/build/Import.js").Import;
+    readonly DatasetCore: import("ts-poet/build/Import.js").Import;
+    readonly datasetFactory: import("ts-poet/build/Import.js").Import;
+    readonly Either: import("ts-poet/build/Import.js").Import;
+    readonly EitherAsync: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLBigInt: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLBoolean: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLDate: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLDateTime: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLFloat: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLID: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLInt: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLList: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLNonNull: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLObjectType: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLSchema: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLString: import("ts-poet/build/Import.js").Import;
+    readonly GraphQLUnionType: import("ts-poet/build/Import.js").Import;
+    readonly Left: import("ts-poet/build/Import.js").Import;
+    readonly Literal: import("ts-poet/build/Import.js").Import;
+    readonly LiteralFactory: import("ts-poet/build/Import.js").Import;
+    readonly Maybe: import("ts-poet/build/Import.js").Import;
+    readonly NamedNode: import("ts-poet/build/Import.js").Import;
+    readonly NonEmptyList: import("ts-poet/build/Import.js").Import;
+    readonly PropertyPath: import("ts-poet/build/Import.js").Import;
+    readonly Quad: import("ts-poet/build/Import.js").Import;
+    readonly Quad_Graph: import("ts-poet/build/Import.js").Import;
+    readonly Resource: import("ts-poet/build/Import.js").Import;
+    readonly ResourceSet: import("ts-poet/build/Import.js").Import;
+    readonly Right: import("ts-poet/build/Import.js").Import;
+    readonly sha256: import("ts-poet/build/Import.js").Import;
+    readonly sparqljs: import("ts-poet/build/Import.js").Import;
+    readonly uuid: import("ts-poet/build/Import.js").Import;
+    readonly Variable: import("ts-poet/build/Import.js").Import;
+    readonly z: import("ts-poet/build/Import.js").Import;
+};
+//# sourceMappingURL=imports.d.ts.map

package/dist/generators/ts/imports.js

@@ -0,0 +1,41 @@
+import { imp } from "./ts-poet-wrapper.js";
+export const imports = {
+    BigDecimal: imp("Decimal:BigDecimal@decimal.js"),
+    BlankNode: imp("BlankNode@@rdfjs/types"),
+    dataFactory: imp("dataFactory=@rdfjs/data-model"),
+    DatasetCore: imp("DatasetCore@@rdfjs/types"),
+    datasetFactory: imp("datasetFactory=@rdfjs/dataset"),
+    Either: imp("Either@purify-ts"),
+    EitherAsync: imp("EitherAsync@purify-ts"),
+    GraphQLBigInt: imp("BigInt:GraphQLBigInt@graphql-scalars"),
+    GraphQLBoolean: imp("GraphQLBoolean@graphql"),
+    GraphQLDate: imp("Date:GraphQLDate@graphql-scalars"),
+    GraphQLDateTime: imp("DateTime:GraphQLDateTime@graphql-scalars"),
+    GraphQLFloat: imp("GraphQLFloat@graphql"),
+    GraphQLID: imp("GraphQLID@graphql"),
+    GraphQLInt: imp("GraphQLInt@graphql"),
+    GraphQLList: imp("GraphQLList@graphql"),
+    GraphQLNonNull: imp("GraphQLNonNull@graphql"),
+    GraphQLObjectType: imp("GraphQLObjectType@graphql"),
+    GraphQLSchema: imp("GraphQLSchema@graphql"),
+    GraphQLString: imp("GraphQLString@graphql"),
+    GraphQLUnionType: imp("GraphQLUnionType@graphql"),
+    Left: imp("Left@purify-ts"),
+    Literal: imp("Literal@@rdfjs/types"),
+    LiteralFactory: imp("LiteralFactory@rdfjs-resource"),
+    Maybe: imp("Maybe@purify-ts"),
+    NamedNode: imp("NamedNode@@rdfjs/types"),
+    NonEmptyList: imp("NonEmptyList@purify-ts"),
+    PropertyPath: imp("PropertyPath@rdfjs-resource"),
+    Quad: imp("Quad@@rdfjs/types"),
+    Quad_Graph: imp("Quad_Graph@@rdfjs/types"),
+    Resource: imp("Resource@rdfjs-resource"),
+    ResourceSet: imp("ResourceSet@rdfjs-resource"),
+    Right: imp("Right@purify-ts"),
+    sha256: imp("sha256@js-sha256"),
+    sparqljs: imp("sparqljs*sparqljs"),
+    uuid: imp("uuid*uuid"),
+    Variable: imp("Variable@@rdfjs/types"),
+    z: imp("z@zod"),
+};
+//# sourceMappingURL=imports.js.map

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

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

package/dist/generators/ts/objectSetDeclarations.js

@@ -1,4 +1,3 @@
-import { forwardingObjectSetClassDeclaration } from "./forwardingObjectSetClassDeclaration.js";
 import { objectSetInterfaceDeclaration } from "./objectSetInterfaceDeclaration.js";
 import { rdfjsDatasetObjectSetClassDeclaration } from "./rdfjsDatasetObjectSetClassDeclaration.js";
 import { sparqlObjectSetClassDeclaration } from "./sparqlObjectSetClassDeclaration.js";
@@ -37,25 +36,24 @@ export function objectSetDeclarations({ objectUnionTypes, ...parameters }) {
         objectUnionTypesWithSparqlFeatureCount === 0) {
         return [];
     }
-    const statements = [
-        ...objectSetInterfaceDeclaration({
+    const declarations = [
+        objectSetInterfaceDeclaration({
             objectTypes,
             objectUnionTypes,
         }),
-        forwardingObjectSetClassDeclaration({ objectTypes, objectUnionTypes }),
     ];
     if (objectTypesWithRdfFeatureCount > 0) {
-        statements.push(rdfjsDatasetObjectSetClassDeclaration({
+        declarations.push(rdfjsDatasetObjectSetClassDeclaration({
             objectTypes,
             objectUnionTypes,
         }));
     }
     if (objectTypesWithSparqlFeatureCount > 0) {
-        statements.push(...sparqlObjectSetClassDeclaration({
+        declarations.push(sparqlObjectSetClassDeclaration({
             objectTypes,
             objectUnionTypes,
         }));
     }
-    return statements;
+    return declarations;
 }
 //# sourceMappingURL=objectSetDeclarations.js.map

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

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

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -1,46 +1,24 @@
-import { StructureKind, } from "ts-morph";
+import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code, joinCode } from "./ts-poet-wrapper.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],
-                },
-            ],
-        },
-    ];
+    return code `\
+export interface ${syntheticNamePrefix}ObjectSet {
+  ${joinCode(objectTypes
+        .flatMap((objectType) => Object.values(objectSetMethodSignatures({ objectType })))
+        .concat(objectUnionTypes.flatMap((objectUnionType) => Object.values(objectSetMethodSignatures({ objectType: objectUnionType }))))
+        .map((methodSignature) => code `${methodSignature.name}(${methodSignature.parameters}): ${methodSignature.returnType};`), { on: "\n\n" })}
+}
+
+export namespace ${syntheticNamePrefix}ObjectSet {
+  export interface Query<ObjectFilterT, ObjectIdentifierT extends ${imports.BlankNode} | ${imports.NamedNode}> {
+    readonly filter?: ObjectFilterT;
+    readonly graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+    readonly identifiers?: readonly ObjectIdentifierT[];
+    readonly limit?: number;
+    readonly offset?: number;
+  }
+}`;
 }
 //# sourceMappingURL=objectSetInterfaceDeclaration.js.map

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

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

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -1,51 +1,31 @@
+import { imports } from "./imports.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { code } from "./ts-poet-wrapper.js";
 export function objectSetMethodSignatures(parameters) {
     const { objectType } = parameters;
+    const parameterNamePrefix = parameters?.parameterNamePrefix ?? "";
     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}>>`,
+            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}`,
+            returnType: code `Promise<${imports.Either}<Error, ${objectType.name}>>`,
+        },
+        objectCount: {
+            name: methodNames.objectCount,
+            parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>, "filter">`,
+            returnType: code `Promise<${imports.Either}<Error, number>>`,
         },
         objectIdentifiers: {
             name: methodNames.objectIdentifiers,
-            parameters: [
-                {
-                    hasQuestionToken: true,
-                    name: "query",
-                    type: `${queryT}<${objectType.identifierTypeAlias}>`,
-                },
-            ],
-            returnType: `Promise<purify.Either<Error, readonly ${objectType.identifierTypeAlias}[]>>`,
+            parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
+            returnType: code `Promise<${imports.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>>",
+            parameters: code `${parameterNamePrefix}query?: ${queryT}<${objectType.filterType}, ${objectType.identifierTypeAlias}>`,
+            returnType: code `Promise<${imports.Either}<Error, readonly ${objectType.name}[]>>`,
         },
     };
 }

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

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