@shaclmate/compiler 4.0.25 → 4.0.26

package/dist/generators/ts/TsGenerator.js

@@ -3,6 +3,7 @@ import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
 import { snippets } from "./snippets.js";
 import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
+import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
@@ -32,13 +33,20 @@ export class TsGenerator {
         }
         const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
         const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        if (namedObjectTypesToposorted.length > 0) {
-            const uberObjectUnionType = synthesizeUberObjectUnionType({
-                logger: this.logger,
-                namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
-            });
-            declarations = declarations.concat(uberObjectUnionType.declaration.toList());
-            namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+        switch (namedObjectTypesNameSorted.length) {
+            case 0:
+                break;
+            case 1:
+                declarations.push(code `type ${syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
+                break;
+            default: {
+                const uberObjectUnionType = synthesizeUberObjectUnionType({
+                    logger: this.logger,
+                    namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+                });
+                declarations = declarations.concat(uberObjectUnionType.declaration.toList());
+                namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+            }
         }
         declarations.push(...objectSetDeclarations({
             namedObjectTypes: namedObjectTypesNameSorted,

package/dist/generators/ts/_NamedObjectType/NamedObjectType_objectSetMethodNames.js

@@ -1,9 +1,14 @@
 import { camelCase, trainCase } from "change-case";
 import plur from "plur";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 export function NamedObjectType_objectSetMethodNames() {
-    const prefixSingular = camelCase(this.name);
-    const thisNameParts = trainCase(this.name).split("-");
-    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
+    const prefixSingular = camelCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    });
+    const thisNameParts = trainCase(this.name, {
+        prefixCharacters: syntheticNamePrefix,
+    }).split("-");
+    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`, { prefixCharacters: syntheticNamePrefix });
     if (prefixPlural === prefixSingular) {
         // Happens with singular-s nouns like "series"
         prefixPlural = `${prefixPlural}s`;

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

@@ -6,7 +6,7 @@ export const snippets_compactRecord = conditionalOutput(`${syntheticNamePrefix}c
  */  
 function ${syntheticNamePrefix}compactRecord<KeyT extends string, ValueT extends {}>(record: Record<KeyT, ValueT | undefined>): Record<KeyT, ValueT> {
   return \
-    Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
+    globalThis.Object.entries(record).reduce((definedProperties, [propertyName, propertyValue]) => {
       if (propertyValue !== undefined) {
         definedProperties[propertyName as KeyT] = propertyValue as ValueT;
       }

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -98,13 +98,13 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                 case "NamedObjectType": {
                     return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.${syntheticNamePrefix}objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+  return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                 }
                 case "NamedObjectUnionType":
                     return delegatingMethods.concat(code `\
 ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.${syntheticNamePrefix}objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+  return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);
@@ -116,7 +116,7 @@ ${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${
         ...(namedObjectTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+#objectsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectType: ${namedObjectTypeType}, ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;
@@ -208,7 +208,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
         ...(namedObjectUnionTypes.length > 0
             ? [
                 code `\
-protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
+#objectUnionsSync<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(namedObjectTypes: readonly ${namedObjectTypeType}[], ${parameters.query}): ${imports.Either}<Error, readonly ObjectT[]> {
   const graph = query?.graph ?? this.${syntheticNamePrefix}graph;
 
   const limit = query?.limit ?? Number.MAX_SAFE_INTEGER;

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -14,6 +14,7 @@ export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectU
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
         selectObjectTypeType: code `namedObjectType: { ${syntheticNamePrefix}focusSparqlWherePatterns: ${snippets.FocusSparqlWherePatternsFunction}<ObjectFilterT> }`,
     };
+    const sparqlClientType = code `{ queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }`;
     const typeParameters = {
         ObjectT: code `ObjectT extends { readonly $identifier: () => ObjectIdentifierT }`,
         ObjectFilterT: code `ObjectFilterT`,
@@ -21,13 +22,15 @@ export function sparqlObjectSetClassDeclaration({ namedObjectTypes, namedObjectU
     };
     return code `\
 export class ${syntheticNamePrefix}SparqlObjectSet implements ${syntheticNamePrefix}ObjectSet {
-  protected readonly ${syntheticNamePrefix}countVariable = ${imports.dataFactory}.variable!("count");;
-  protected readonly graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
-  protected readonly ${syntheticNamePrefix}objectVariable = ${imports.dataFactory}.variable!("object");
-  protected readonly ${syntheticNamePrefix}sparqlGenerator = new ${imports.sparqljs}.Generator();
-
-  constructor(protected readonly ${syntheticNamePrefix}sparqlClient: { queryBindings: (query: string) => Promise<readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[]>; queryQuads: (query: string) => Promise<readonly ${imports.Quad}[]>; }, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
-    this.graph = options?.graph;
+  readonly #countVariable = ${imports.dataFactory}.variable!("count");;
+  readonly #graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>;
+  readonly #objectVariable = ${imports.dataFactory}.variable!("object");
+  readonly #sparqlClient: ${sparqlClientType};
+  readonly #sparqlGenerator = new ${imports.sparqljs}.Generator();
+
+  constructor(sparqlClient: ${sparqlClientType}, options?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}> }) {
+    this.#graph = options?.graph;
+    this.#sparqlClient = sparqlClient;
   }
 
 ${joinCode([...namedObjectTypes, ...namedObjectUnionTypes].flatMap((namedObjectType) => {
@@ -48,20 +51,20 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
             code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
-  return this.${syntheticNamePrefix}objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objectCount<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdentifiers.parameters}): ${methodSignatures.objectIdentifiers.returnType} {
-  return this.${syntheticNamePrefix}objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objectIdentifiers<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
-  return this.${syntheticNamePrefix}objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
         ];
     }), { on: "\n\n" })}
 
-  protected ${syntheticNamePrefix}mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
+  #mapBindingsToCount(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): ${imports.Either}<Error, number> {
     if (bindings.length === 0) {
       return ${imports.Left}(new Error("empty result rows"));
     }
@@ -82,7 +85,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     return ${imports.Right}(parsedCount);
   }
 
-  protected ${syntheticNamePrefix}mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
+  #mapBindingsToIdentifiers(bindings: readonly Record<string, ${imports.BlankNode} | ${imports.Literal} | ${imports.NamedNode}>[], variable: string): readonly ${imports.NamedNode}[] {
     const identifiers: ${imports.NamedNode}[] = [];
     for (const bindings_ of bindings) {
       const identifier = bindings_[variable];
@@ -96,7 +99,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     return identifiers;
   }
 
-  protected async ${syntheticNamePrefix}objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
+  async #objectIdentifiers<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectIdentifierT[]>> {
     if (query?.identifiers) {
       return ${imports.Right}(query.identifiers);
     }
@@ -111,41 +114,41 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       offset = 0;
     }
 
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
+    const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for identifiers"));
     }
 
     const selectQueryString = \
-      this.${syntheticNamePrefix}sparqlGenerator.stringify({
+      this.#sparqlGenerator.stringify({
         distinct: true,
         limit: limit < Number.MAX_SAFE_INTEGER ? limit : undefined,
         offset,
-        order: query?.order ? query.order(this.${syntheticNamePrefix}objectVariable).concat() : [{ expression: this.${syntheticNamePrefix}objectVariable }],
+        order: query?.order ? query.order(this.#objectVariable).concat() : [{ expression: this.#objectVariable }],
         prefixes: {},
         queryType: "SELECT",
         type: "query",
-        variables: [this.${syntheticNamePrefix}objectVariable],
+        variables: [this.#objectVariable],
         where: wherePatterns.concat()
       });
       
     return ${imports.EitherAsync}(async () =>
-      this.${syntheticNamePrefix}mapBindingsToIdentifiers(
-        await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
-        this.${syntheticNamePrefix}objectVariable.value,
+      this.#mapBindingsToIdentifiers(
+        await this.#sparqlClient.queryBindings(selectQueryString),
+        this.#objectVariable.value,
       ) as readonly ObjectIdentifierT[],
     );  
   }
 
-  protected async ${syntheticNamePrefix}objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
+  async #objects<${typeParameters.ObjectT}, ${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.constructObjectType}, ${parameters.query}): Promise<${imports.Either}<Error, readonly ObjectT[]>> {
     return ${imports.EitherAsync}(async ({ liftEither }) => {
-      const identifiers = await liftEither(await this.${syntheticNamePrefix}objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
+      const identifiers = await liftEither(await this.#objectIdentifiers<ObjectFilterT, ObjectIdentifierT>(namedObjectType, query));
       if (identifiers.length === 0) {
         return [];
       }
 
       const constructQueryString = namedObjectType.${syntheticNamePrefix}sparqlConstructQueryString({
-        subject: this.${syntheticNamePrefix}objectVariable,
+        subject: this.#objectVariable,
         where: [{
           type: "values" as const,
           values: identifiers.map((identifier) => {
@@ -156,7 +159,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
         }]
       });
 
-      const quads = await this.${syntheticNamePrefix}sparqlClient.queryQuads(constructQueryString);
+      const quads = await this.#sparqlClient.queryQuads(constructQueryString);
 
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
@@ -167,14 +170,14 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
     });
   }
 
-  protected async ${syntheticNamePrefix}objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
-    const wherePatterns = this.${syntheticNamePrefix}wherePatterns(namedObjectType, query);
+  async #objectCount<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): Promise<${imports.Either}<Error, number>> {
+    const wherePatterns = this.#wherePatterns(namedObjectType, query);
     if (wherePatterns.length === 0) {
       return ${imports.Left}(new Error("no SPARQL WHERE patterns for count"));
     }
 
     const selectQueryString = \
-      this.${syntheticNamePrefix}sparqlGenerator.stringify({
+      this.#sparqlGenerator.stringify({
         prefixes: {},
         queryType: "SELECT",
         type: "query",
@@ -183,10 +186,10 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
             expression: {
               aggregation: "COUNT",
               distinct: true,
-              expression: this.${syntheticNamePrefix}objectVariable,
+              expression: this.#objectVariable,
               type: "aggregate",
             },
-            variable: this.${syntheticNamePrefix}countVariable,
+            variable: this.#countVariable,
           },
         ],
         where: wherePatterns.concat()
@@ -194,27 +197,27 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
 
     return ${imports.EitherAsync}(async ({ liftEither }) =>
       liftEither(
-        this.${syntheticNamePrefix}mapBindingsToCount(
-          await this.${syntheticNamePrefix}sparqlClient.queryBindings(selectQueryString),
-          this.${syntheticNamePrefix}countVariable.value,
+        this.#mapBindingsToCount(
+          await this.#sparqlClient.queryBindings(selectQueryString),
+          this.#countVariable.value,
         ),
       ),
     );
   }
 
-  protected ${syntheticNamePrefix}wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
+  #wherePatterns<${typeParameters.ObjectFilterT}, ${typeParameters.ObjectIdentifierT}>(${parameters.selectObjectTypeType}, ${parameters.query}): readonly ${imports.sparqljs}.Pattern[] {
     // Patterns should be most to least specific.
     let patterns: ${imports.sparqljs}.Pattern[] = [];
 
     if (query?.where) {
-      patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
+      patterns = patterns.concat(query.where(this.#objectVariable));
     }
 
-    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
+    patterns = patterns.concat(namedObjectType.${syntheticNamePrefix}focusSparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.#objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.#objectVariable.value }));
 
     patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
 
-    const graph = query?.graph ?? this.graph;
+    const graph = query?.graph ?? this.#graph;
     if (graph) {
       switch (graph.termType) {
         case "DefaultGraph":

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.25",
+    "@shaclmate/shacl-ast": "4.0.26",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.25"
+  "version": "4.0.26"
 }