feat: variable representation overrides

Author: tpluscode

.changeset/long-keys-deny.md

@@ -0,0 +1,5 @@
+---
+"@hydrofoil/labyrinth": patch
+---
+
+Support for `hydra:variableRepresentation` on template mapping level

packages/labyrinth/lib/template.ts

@@ -10,8 +10,8 @@ import { isUri } from 'valid-url'
 const literalValueRegex = /^"(?<value>.+)"(@|\^\^)?((?<=@)(?<language>.*))?((?<=\^\^)(?<datatype>.*))?$/
 const TRUE = $rdf.literal('true', xsd.boolean)
 
-function createTermFromVariable({ template, value }: {template: GraphPointer; value: string}) {
-  if (!hydra.ExplicitRepresentation.equals(template.out(hydra.variableRepresentation).term)) {
+function createTermFromVariable({ variableRepresentation, value }: { variableRepresentation: Term | undefined; value: string}) {
+  if (!hydra.ExplicitRepresentation.equals(variableRepresentation)) {
     return value
   }
 
@@ -30,19 +30,21 @@ function createTermFromVariable({ template, value }: {template: GraphPointer; va
 
 export function toPointer(template: GraphPointer, queryParams: ParsedQs): GraphPointer<BlankNode, DatasetExt> {
   const templateParams = clownface({ dataset: $rdf.dataset() }).blankNode()
+  const templateVariableRepresentation = template.out(hydra.variableRepresentation).term
 
-  const variablePropertyMap = new Map<string, Term>()
+  const variablePropertyMap = new Map<string, { property: Term; variableRepresentation: Term | undefined }>()
   template.out(hydra.mapping).forEach(mapping => {
     const variable = mapping.out(hydra.variable).value
     const property = mapping.out(hydra.property).term
     const required = mapping.out(hydra.required).term?.equals(TRUE)
+    const variableRepresentation = mapping.out(hydra.variableRepresentation).term
 
     if (variable && required && !queryParams[variable]) {
       throw new httpError.BadRequest(`Missing required template variable ${variable}`)
     }
 
     if (variable && property) {
-      variablePropertyMap.set(variable, property)
+      variablePropertyMap.set(variable, { property, variableRepresentation })
     }
   })
 
@@ -53,14 +55,18 @@ export function toPointer(template: GraphPointer, queryParams: ParsedQs): GraphP
         ? param.map((item: any) => item.toString())
         : []
 
-    const property = variablePropertyMap.get(key)
+    const mapping = variablePropertyMap.get(key)
 
-    if (!property) {
+    if (!mapping) {
       return
     }
 
-    const terms = values.map(value => createTermFromVariable({ template, value }))
-    templateParams.addOut(property, terms)
+    const variableRepresentation = mapping.variableRepresentation || templateVariableRepresentation
+    const terms = values.map(value => createTermFromVariable({
+      variableRepresentation,
+      value,
+    }))
+    templateParams.addOut(mapping.property, terms)
   })
 
   return templateParams

packages/labyrinth/test/lib/template.test.ts

@@ -76,5 +76,67 @@ describe('@hydrofoil/labyrinth/lib/template', () => {
       expect(graph.out(schema.age).term).to.deep.eq($rdf.literal('20', xsd.unsignedInt))
       expect(graph.out(schema.identifier).term).to.deep.eq(schema.Person)
     })
+
+    it('supports variable representation override by variable', () => {
+      // given
+      const template = fromPointer(blankNode(), {
+        template: '/{name},{age},{type}',
+        variableRepresentation: hydra.BasicRepresentation,
+        mapping: [{
+          variable: 'name',
+          property: schema.name,
+        }, {
+          variable: 'age',
+          property: schema.age,
+        }, {
+          variableRepresentation: hydra.ExplicitRepresentation,
+          variable: 'type',
+          property: schema.identifier,
+        }],
+      })
+
+      // when
+      const graph = toPointer(template.pointer, {
+        age: `"20"^^${xsd.unsignedInt.value}`,
+        name: '"John"@en',
+        type: schema.Person.value,
+      })
+
+      // then
+      expect(graph.out(schema.age).term).to.deep.eq($rdf.literal(`"20"^^${xsd.unsignedInt.value}`))
+      expect(graph.out(schema.name).term).to.deep.eq($rdf.literal('"John"@en'))
+      expect(graph.out(schema.identifier).term).to.deep.eq(schema.Person)
+    })
+
+    it('supports variable representation override by variable', () => {
+      // given
+      const template = fromPointer(blankNode(), {
+        template: '/{name},{age},{type}',
+        variableRepresentation: hydra.ExplicitRepresentation,
+        mapping: [{
+          variable: 'name',
+          property: schema.name,
+        }, {
+          variable: 'age',
+          property: schema.age,
+        }, {
+          variableRepresentation: hydra.BasicRepresentation,
+          variable: 'type',
+          property: schema.identifier,
+        }],
+      })
+
+      // when
+      const graph = toPointer(template.pointer, {
+        age: `"20"^^${xsd.unsignedInt.value}`,
+        name: '"John"@en',
+        type: schema.Person.value,
+      })
+
+      // then
+      expect(graph.out(schema.name).term).to.deep.eq($rdf.literal('John', 'en'))
+      expect(graph.out(schema.age).term).to.deep.eq($rdf.literal('20', xsd.unsignedInt))
+      expect(graph.out(schema.identifier).term).to.deep.eq($rdf.literal(schema.Person.value))
+    })
   })
 })