feat: add initial requestThingDescription implementation

packages/binding-coap/src/coap-client.ts

@@ -183,6 +183,24 @@ export default class CoapClient implements ProtocolClient {
         });
     }
 
+    /**
+     * @inheritdoc
+     */
+    requestThingDescription(uri: string): Promise<Content> {
+        const options: CoapRequestParams = this.uriToOptions(uri);
+        const req = this.agent.request(options);
+
+        req.setOption("Accept", "application/td+json");
+        return new Promise<Content>((resolve, reject) => {
+            req.on("response", (res: IncomingMessage) => {
+                const contentType = (res.headers["Content-Format"] as string) ?? "application/td+json";
+                resolve(new Content(contentType, Readable.from(res.payload)));
+            });
+            req.on("error", (err: Error) => reject(err));
+            req.end();
+        });
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }

packages/binding-coap/src/coaps-client.ts

@@ -139,6 +139,23 @@ export default class CoapsClient implements ProtocolClient {
         });
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        const response = await coaps.request(uri, "get", undefined, {
+            // FIXME: Add accept option
+            //       Currently not supported by node-coap-client
+        });
+
+        // TODO: Respect Content-Format in response.
+        //       Currently not really well supported by node-coap-client
+        const contentType = "application/td+json";
+        const payload = response.payload ?? Buffer.alloc(0);
+
+        return new Content(contentType, Readable.from(payload));
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }

packages/binding-file/src/file-client.ts

@@ -72,6 +72,13 @@ export default class FileClient implements ProtocolClient {
         throw new Error("FileClient does not implement unlink");
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Not implemented");
+    }
+
     public async subscribeResource(
         form: Form,
         next: (value: Content) => void,

packages/binding-http/src/http-client-impl.ts

@@ -212,6 +212,18 @@ export default class HttpClient implements ProtocolClient {
         }
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        const headers: HeadersInit = {
+            Accept: "application/td+json",
+        };
+        const response = await fetch(uri, { headers });
+        const body = ProtocolHelpers.toNodeStream(response.body as Readable);
+        return new Content(response.headers.get("content-type") ?? "application/td+json", body);
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }

packages/binding-mbus/src/mbus-client.ts

@@ -61,6 +61,13 @@ export default class MBusClient implements ProtocolClient {
         throw new Error("Method not implemented.");
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented");
+    }
+
     async start(): Promise<void> {
         // do nothing
     }

packages/binding-modbus/src/modbus-client.ts

@@ -131,6 +131,13 @@ export default class ModbusClient implements ProtocolClient {
         });
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented");
+    }
+
     async start(): Promise<void> {
         // do nothing
     }

packages/binding-mqtt/src/mqtt-client.ts

@@ -161,6 +161,13 @@ export default class MqttClient implements ProtocolClient {
         }
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented");
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }

packages/binding-netconf/src/netconf-client.ts

@@ -155,6 +155,13 @@ export default class NetconfClient implements ProtocolClient {
         throw unimplementedError;
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented");
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }

packages/binding-opcua/src/opcua-protocol-client.ts

@@ -430,6 +430,13 @@ export class OPCUAProtocolClient implements ProtocolClient {
         });
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented");
+    }
+
     start(): Promise<void> {
         debug("start: Sorry not implemented");
         throw new Error("Method not implemented.");

packages/binding-websockets/src/ws-client.ts

@@ -66,6 +66,13 @@ export default class WebSocketClient implements ProtocolClient {
         throw new Error("Websocket client does not implement subscribeResource");
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented");
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }

packages/core/src/protocol-interfaces.ts

@@ -66,6 +66,16 @@ export interface ProtocolClient {
         complete?: () => void
     ): Promise<Subscription>;
 
+    /**
+     * Requests a single Thing Description from a given {@link uri}.
+     *
+     * The result is returned asynchronously as {@link Content}, which has to
+     * be deserialized and validated by the upper layers of the implementation.
+     *
+     * @param uri
+     */
+    requestThingDescription(uri: string): Promise<Content>;
+
     /** start the client (ensure it is ready to send requests) */
     start(): Promise<void>;
     /** stop the client */

packages/core/src/wot-impl.ts

@@ -20,6 +20,7 @@ import ExposedThing from "./exposed-thing";
 import ConsumedThing from "./consumed-thing";
 import Helpers from "./helpers";
 import { createLoggers } from "./logger";
+import ContentManager from "./content-serdes";
 
 const { debug } = createLoggers("core", "wot-impl");
 
@@ -39,8 +40,20 @@ export default class WoTImpl {
         throw new Error("not implemented");
     }
 
+    /** @inheritDoc */
     async requestThingDescription(url: string): Promise<WoT.ThingDescription> {
-        throw new Error("not implemented");
+        const uriScheme = new URL(url).protocol.split(":")[0];
+        const client = this.srv.getClientFor(uriScheme);
+        const result = await client.requestThingDescription(url);
+
+        const value = ContentManager.contentToValue({ type: result.type, body: await result.toBuffer() }, {});
+
+        if (value instanceof Object) {
+            // TODO: Add validation step
+            return value as WoT.ThingDescription;
+        }
+
+        throw new Error("Not found.");
     }
 
     /** @inheritDoc */

packages/core/test/ClientTest.ts

@@ -156,6 +156,10 @@ class TDClient implements ProtocolClient {
         return new Subscription();
     }
 
+    async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }
@@ -230,6 +234,10 @@ class TrapClient implements ProtocolClient {
         return new Subscription();
     }
 
+    async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
+
     public async start(): Promise<void> {
         // do nothing
     }
@@ -293,6 +301,10 @@ class TestProtocolClient implements ProtocolClient {
         throw new Error("Method not implemented.");
     }
 
+    async requestThingDescription(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
+
     async start(): Promise<void> {
         throw new Error("Method not implemented.");
     }