feat: add initial requestThingDescription implementation (#1166)

* feat: add initial requestThingDescription implementation

Author: JKRhb

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

@@ -24,40 +24,48 @@ import path = require("path");
 
 const { debug, warn } = createLoggers("binding-file", "file-client");
 
+/**
+ * Used to determine the Content-Type of a file from the extension in its
+ * {@link filePath} if no explicit Content-Type is defined.
+ *
+ * @param filepath The file path the Content-Type is determined for.
+ * @returns An appropriate Content-Type or `application/octet-stream` as a fallback.
+ */
+function mapFileExtensionToContentType(filepath: string) {
+    const fileExtension = path.extname(filepath);
+    debug(`FileClient found '${fileExtension}' extension`);
+    switch (fileExtension) {
+        case ".txt":
+        case ".log":
+        case ".ini":
+        case ".cfg":
+            return "text/plain";
+        case ".json":
+            return "application/json";
+        case ".jsontd":
+            return "application/td+json";
+        case ".jsonld":
+            return "application/ld+json";
+        default:
+            warn(`FileClient cannot determine media type for path '${filepath}'`);
+            return "application/octet-stream";
+    }
+}
+
 export default class FileClient implements ProtocolClient {
     public toString(): string {
         return "[FileClient]";
     }
 
+    private async readFile(filepath: string, contentType?: string): Promise<Content> {
+        const resource = fs.createReadStream(filepath);
+        const resourceContentType = contentType ?? mapFileExtensionToContentType(filepath);
+        return new Content(resourceContentType, resource);
+    }
+
     public async readResource(form: Form): Promise<Content> {
-        const filepath = form.href.split("//");
-        const resource = fs.createReadStream(filepath[1]);
-        const extension = path.extname(filepath[1]);
-        debug(`FileClient found '${extension}' extension`);
-        let contentType;
-        if (form.contentType != null) {
-            contentType = form.contentType;
-        } else {
-            // *guess* contentType based on file extension
-            contentType = "application/octet-stream";
-            switch (extension) {
-                case ".txt":
-                case ".log":
-                case ".ini":
-                case ".cfg":
-                    contentType = "text/plain";
-                    break;
-                case ".json":
-                    contentType = "application/json";
-                    break;
-                case ".jsonld":
-                    contentType = "application/ld+json";
-                    break;
-                default:
-                    warn(`FileClient cannot determine media type of '${form.href}'`);
-            }
-        }
-        return new Content(contentType, resource);
+        const filepath = new URL(form.href).pathname;
+        return this.readFile(filepath, form.contentType);
     }
 
     public async writeResource(form: Form, content: Content): Promise<void> {
@@ -72,6 +80,13 @@ export default class FileClient implements ProtocolClient {
         throw new Error("FileClient does not implement unlink");
     }
 
+    /**
+     * @inheritdoc
+     */
+    public async requestThingDescription(uri: string): Promise<Content> {
+        return this.readFile(uri, "application/td+json");
+    }
+
     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
     }