Allow hash keys to be URIs that dereference to a string

Closes #115

Author: joachimvh

lib/construction/argument/ArgumentConstructorHandlerHash.ts

@@ -29,14 +29,16 @@ export class ArgumentConstructorHandlerHash implements IArgumentConstructorHandl
       if (!entry.property.key) {
         throw new ErrorResourcesContext(`Missing key in fields entry`, { entry, argument });
       }
-      if (entry.property.key.type !== 'Literal') {
-        throw new ErrorResourcesContext(`Illegal non-literal key (${entry.property.key.value} as ${entry.property.key.type}) in fields entry`, { entry, argument });
+
+      const key = await argsCreator.getArgumentValues(entry.properties.key, settings);
+      if (typeof key !== 'string') {
+        throw new ErrorResourcesContext(`Illegal non-string key (${entry.property.key.value} as ${entry.property.key.type}) in fields entry`, { entry, argument });
       }
 
       // Recursively get value arg value
       if (entry.property.value) {
         const subValue = await argsCreator.getArgumentValues(entry.properties.value, settings);
-        return { key: entry.property.key.value, value: subValue };
+        return { key, value: subValue };
       }
 
       // Ignore cases where value may not be set, because params may be optional

lib/construction/strategy/ConstructionStrategyCommonJsString.ts

@@ -94,7 +94,7 @@ export class ConstructionStrategyCommonJsString implements IConstructionStrategy
         }
         sb.push('\n');
         sb.push('  ');
-        sb.push(`'${entry.key}'`);
+        sb.push(`${entry.key}`);
         sb.push(': ');
         sb.push(entry.value);
       }

test/unit/construction/ConfigConstructor-test.ts

@@ -12,7 +12,7 @@ const DF = new DataFactory();
 describe('ConfigConstructor', () => {
   let objectLoader: RdfObjectLoader;
   let componentResources: Record<string, Resource>;
-  let configConstructorPool: ConfigConstructorPool<any>;
+  let configConstructorPool: jest.Mocked<ConfigConstructorPool<any>>;
   let constructor: ConfigConstructor<any>;
   let constructionStrategy: IConstructionStrategy<any>;
   let moduleState: IModuleState;
@@ -224,7 +224,7 @@ describe('ConfigConstructor', () => {
           .toThrowError(/^Missing key in fields entry/u);
       });
 
-      it('should throw on IRI key', async() => {
+      it('can use dereferenced IRI values as keys', async() => {
         const resource = objectLoader.createCompactedResource({
           fields: {
             list: [
@@ -235,8 +235,39 @@ describe('ConfigConstructor', () => {
             ],
           },
         });
+        expect(await constructor.getArgumentValue(resource, settings)).toEqual({
+          entries: [
+            {
+              key: 'INSTANCE',
+              value: 'ABC',
+            },
+          ],
+        });
+        expect(constructionStrategy.createHash).toHaveBeenCalledWith({
+          settings,
+          entries: [
+            {
+              key: 'INSTANCE',
+              value: 'ABC',
+            },
+          ],
+        });
+      });
+
+      it('should throw on non-string keys', async() => {
+        configConstructorPool.instantiate.mockResolvedValueOnce(new Error('this is an object'));
+        const resource = objectLoader.createCompactedResource({
+          fields: {
+            list: [
+              {
+                key: `ex:abc`,
+                value: '"ABC"',
+              },
+            ],
+          },
+        });
         await expect(constructor.getArgumentValue(resource, settings)).rejects
-          .toThrowError(/^Illegal non-literal key \(ex:abc as NamedNode\) in fields entry/u);
+          .toThrowError(/^Illegal non-string key \(ex:abc as NamedNode\) in fields entry/u);
       });
 
       it('should ignore fields without value', async() => {

test/unit/construction/strategy/ConstructionStrategyCommonJsString-test.ts

@@ -290,39 +290,39 @@ module.exports = urn_comunica_sparqlinit;
       expect(constructionStrategy.createHash({
         settings,
         entries: [
-          { key: 'a', value: '1' },
-          { key: 'b', value: '2' },
-          { key: 'c', value: '3' },
+          { key: '"a"', value: '1' },
+          { key: '"b"', value: '2' },
+          { key: '"c"', value: '3' },
         ],
       })).toEqual(`{
-  'a': 1,
-  'b': 2,
-  'c': 3
+  "a": 1,
+  "b": 2,
+  "c": 3
 }`);
     });
 
     it('for defined and undefined entries', () => {
       expect(constructionStrategy.createHash({
         settings,
         entries: [
-          { key: 'a', value: '1' },
+          { key: '"a"', value: '1' },
           undefined,
-          { key: 'c', value: '3' },
+          { key: '"c"', value: '3' },
         ],
       })).toEqual(`{
-  'a': 1,
-  'c': 3
+  "a": 1,
+  "c": 3
 }`);
     });
 
     it('for defined entries with array values', () => {
       expect(constructionStrategy.createHash({
         settings,
         entries: [
-          { key: 'a', value: '[\n  a,\n  b\n]' },
+          { key: '"a"', value: '[\n  a,\n  b\n]' },
         ],
       })).toEqual(`{
-  'a': [
+  "a": [
   a,
   b
 ]