fix: class constraint in node shape

.changeset/giant-peaches-switch.md

@@ -0,0 +1,5 @@
+---
+"@hydrofoil/shape-to-query": patch
+---
+
+When used in node shape, class constraint would produce an incorrect pattern

.changeset/red-plums-compete.md

@@ -0,0 +1,5 @@
+---
+"@hydrofoil/shape-to-query": minor
+---
+
+Change the abstract methods of constraint components to separate property shape and node shape constraints

.mocharc.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  'watch-files': [
+    './**/*.ts'
+  ],
+  require: require.resolve('./mocha-setup.cjs'),
+  loader: 'ts-node/esm'
+}

package.json

@@ -47,15 +47,6 @@
   "workspaces": [
     "packages/*"
   ],
-  "mocha": {
-    "watch-files": [
-      "./**/*.ts"
-    ],
-    "require": [
-      "mocha-setup.cjs"
-    ],
-    "loader": "ts-node/esm"
-  },
   "lint-staged": {
     "*.{js,ts}": [
       "eslint --fix --quiet"

packages/demo/public/docs/example/in.ttl.rq

@@ -10,6 +10,4 @@ WHERE {
   { ?resource1 schema:familyName ?resource3. }
   UNION
   { ?resource1 schema:knows ?resource4. }
-  ?resource1 schema:knows ?resource4.
-  FILTER(?resource4 IN(<https://tbbt.tv/sheldon-cooper>, <https://tbbt.tv/stuart-bloom>))
 }

packages/shape-to-query/model/constraint/ConstraintComponent.ts

@@ -21,7 +21,19 @@ export abstract class ConstraintComponent {
   protected constructor(public readonly type: NamedNode) {
   }
 
-  abstract buildPatterns(arg: Parameters): string | SparqlTemplateResult | SparqlTemplateResult[]
+  buildPatterns(arg: Parameters): string | SparqlTemplateResult | SparqlTemplateResult[] {
+    if (arg.propertyPath) {
+      return this.buildPropertyShapePatterns(arg)
+    }
+
+    return this.buildNodeShapePatterns(arg)
+  }
+
+  buildNodeShapePatterns(arg: Parameters): string | SparqlTemplateResult | SparqlTemplateResult[] {
+    return this.buildPropertyShapePatterns(arg)
+  }
+
+  abstract buildPropertyShapePatterns(arg: Parameters): string | SparqlTemplateResult | SparqlTemplateResult[]
 }
 
 export function assertList(arg: ListOrPointer): asserts arg is List {

packages/shape-to-query/model/constraint/and.ts

@@ -18,7 +18,7 @@ export class AndConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns(arg: Parameters): SparqlTemplateResult {
+  buildPropertyShapePatterns(arg: Parameters): SparqlTemplateResult {
     return sparql`${this.inner.map(inner => inner.buildConstraints(arg))}`
   }
 }

packages/shape-to-query/model/constraint/class.ts

@@ -20,7 +20,11 @@ export class ClassConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns({ valueNode }: Parameters) {
+  buildPropertyShapePatterns({ valueNode }: Parameters) {
     return sparql`${valueNode} a ${this.clas} .`
   }
+
+  buildNodeShapePatterns({ focusNode }: Parameters) {
+    return sparql`${focusNode} a ${this.clas} .`
+  }
 }

packages/shape-to-query/model/constraint/expression.ts

@@ -19,7 +19,7 @@ export class ExpressionConstraintComponent extends ConstraintComponent {
     super(sh.ExpressionConstraintComponent)
   }
 
-  buildPatterns({ focusNode: subject, valueNode: object, rootPatterns, variable }: Parameters) {
+  buildPropertyShapePatterns({ focusNode: subject, valueNode: object, rootPatterns, variable }: Parameters) {
     let patterns: Select | SparqlTemplateResult
     let filter: SparqlValue
 

packages/shape-to-query/model/constraint/hasValue.ts

@@ -17,11 +17,11 @@ export class HasValueConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns({ focusNode, propertyPath, valueNode }: Omit<Parameters, 'rootPatterns'>): string | SparqlTemplateResult {
-    if (!propertyPath) {
-      return ''
-    }
+  buildNodeShapePatterns(): string | SparqlTemplateResult | SparqlTemplateResult[] {
+    return ''
+  }
 
+  buildPropertyShapePatterns({ focusNode, propertyPath, valueNode }: Omit<Parameters, 'rootPatterns'>): string | SparqlTemplateResult {
     if (this.terms.length === 1) {
       return sparql`FILTER( ${valueNode} = ${this.terms[0]} )`
     }

packages/shape-to-query/model/constraint/in.ts

@@ -17,7 +17,11 @@ export class InConstraintComponent extends ConstraintComponent {
     super(sh.InConstraintComponent)
   }
 
-  buildPatterns({ valueNode, propertyPath }: Omit<Parameters, 'rootPatterns'>): string | SparqlTemplateResult {
+  buildPropertyShapePatterns(): string | SparqlTemplateResult | SparqlTemplateResult[] {
+    return ''
+  }
+
+  buildNodeShapePatterns({ valueNode, propertyPath }: Omit<Parameters, 'rootPatterns'>): string | SparqlTemplateResult {
     if (!propertyPath) {
       return ''
     }

packages/shape-to-query/model/constraint/node.ts

@@ -16,7 +16,7 @@ export class NodeConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns({ valueNode, variable, ...arg }: Parameters) {
+  buildPropertyShapePatterns({ valueNode, variable, ...arg }: Parameters) {
     return this.shape.buildConstraints({
       ...arg,
       variable,

packages/shape-to-query/model/constraint/nodeKind.ts

@@ -58,7 +58,7 @@ export class NodeKindConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns({ valueNode }: Pick<Parameters, 'valueNode'>) {
+  buildPropertyShapePatterns({ valueNode }: Pick<Parameters, 'valueNode'>) {
     return sparql`FILTER( ${this.__createFilterExpression(valueNode)} )`
   }
 }

packages/shape-to-query/model/constraint/or.ts

@@ -19,7 +19,7 @@ export class OrConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns(arg: Parameters): SparqlTemplateResult {
+  buildPropertyShapePatterns(arg: Parameters): SparqlTemplateResult {
     const propExpr = arg.propertyPath ? sparql`${arg.focusNode} ${arg.propertyPath} ${arg.valueNode} .` : ''
 
     const inner = this.inner

packages/shape-to-query/model/constraint/pattern.ts

@@ -24,7 +24,7 @@ export class PatternConstraintComponent extends ConstraintComponent {
     super(sh.PatternConstraintComponent)
   }
 
-  buildPatterns({ valueNode }: Parameters) {
+  buildPropertyShapePatterns({ valueNode }: Parameters) {
     const flags = this.flags ? `, "${this.flags}"` : ''
 
     return sparql`FILTER(REGEX(${valueNode}, "${this.pattern}"${flags}))`

packages/shape-to-query/model/constraint/property.ts

@@ -16,7 +16,7 @@ export class PropertyConstraintComponent extends ConstraintComponent {
     }
   }
 
-  buildPatterns(arg: Parameters) {
+  buildPropertyShapePatterns(arg: Parameters) {
     return this.shape.buildConstraints(arg)
   }
 }

packages/shape-to-query/package.json

@@ -64,5 +64,8 @@
     "string-to-stream": "^3.0.1",
     "tbbt-ld": "^1.1.0",
     "wait-on": "^7.0.1"
+  },
+  "mocha": {
+    "config": "../../.mocharc.cjs"
   }
 }

packages/shape-to-query/test/model/constraint/class.test.ts

@@ -0,0 +1,49 @@
+import { schema } from '@tpluscode/rdf-ns-builders'
+import { expect } from 'chai'
+import $rdf from 'rdf-ext'
+import { sparql } from '@tpluscode/rdf-string'
+import { variable } from '../../variable.js'
+import { ClassConstraintComponent } from '../../../model/constraint/class.js'
+
+describe('model/constraint/class', () => {
+  before(() => import('../../sparql.js'))
+
+  describe('buildPatterns', () => {
+    context('node shape', () => {
+      it('creates correct pattern', () => {
+        // given
+        const constraint = new ClassConstraintComponent(schema.DefinedTerm)
+
+        // when
+        const whereClause = constraint.buildPatterns({
+          focusNode: $rdf.namedNode('this'),
+          valueNode: variable(),
+          variable,
+          rootPatterns: undefined,
+        })
+
+        // then
+        expect(whereClause).to.equalPatterns('<this> a schema:DefinedTerm .')
+      })
+    })
+
+    context('property shape', () => {
+      it('creates correct pattern', () => {
+        // given
+        const constraint = new ClassConstraintComponent(schema.DefinedTerm)
+
+        // when
+        const whereClause = constraint.buildPatterns({
+          focusNode: $rdf.namedNode('this'),
+          valueNode: variable(),
+          variable,
+          rootPatterns: undefined,
+          propertyPath: sparql`prop`,
+        })
+
+        // then
+        expect(whereClause).to.equalPatterns('?valueNode a schema:DefinedTerm .')
+      })
+    })
+  })
+})