Function-based discovery API alternative

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

@@ -55,6 +55,21 @@
         registerFormat(ContentSerdes.JSON_LD, 2100);
     }
 
+    discoverDirectly(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 toString(): string {
         return "[CoapClient]";
     }

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

@@ -235,4 +235,8 @@
 
         return req;
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -90,4 +90,8 @@
     }
 
     public setSecurity = (metadata: Array<SecurityScheme>): boolean => false;
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -409,4 +409,15 @@
 
         return url;
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        // Note: This is still work in progress
+        const headers: HeadersInit = {
+            Accept: "application/td+json",
+        };
+        const response = await fetch(uri, { headers });
+        // TODO: Result should be validated
+        const body = ProtocolHelpers.toNodeStream(response.body as Readable);
+        return new Content(response.headers.get("content-type") ?? "application/td+json", body);
+    }
 }

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

@@ -144,4 +144,8 @@
 
         return result;
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -309,4 +309,8 @@
 
         return result as ModbusFormWithDefaults;
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -199,4 +199,8 @@
                 return (qos = 0);
         }
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -175,4 +175,8 @@
         this.credentials = credentials;
         return true;
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -620,4 +620,8 @@
 
         return new Content("application/json", Readable.from(JSON.stringify(body)));
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
 }

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

@@ -29,6 +29,10 @@ export default class WebSocketClient implements ProtocolClient {
         // TODO: implement and remove eslint-ignore-useless-constructor
     }
 
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("Method not implemented.");
+    }
+
     public toString(): string {
         return `[WebSocketClient]`;
     }

packages/core/example/example.js

@@ -0,0 +1,28 @@
+const { Servient } = require("@node-wot/core");
+const { HttpClientFactory } = require("@node-wot/binding-http");
+const { CoapClientFactory } = require("@node-wot/binding-coap");
+
+// Note: This example is just for testing/demonstration purposes and
+//       will eventually be removed/moved to the examples package.
+async function discover() {
+    const servient = new Servient();
+    servient.addClientFactory(new HttpClientFactory());
+    servient.addClientFactory(new CoapClientFactory());
+    const wot = await servient.start();
+
+    const httpUrl = "http://plugfest.thingweb.io:8083/smart-coffee-machine";
+    const coapUrl = "coap://plugfest.thingweb.io:5683/smart-coffee-machine";
+
+    for (const url of [httpUrl, coapUrl]) {
+        console.log(await wot.discovery.direct(url));
+    }
+
+    // Alternative approach
+    for (const url of [httpUrl, coapUrl]) {
+        for await (const result of wot.discovery.directIterator(url)) {
+            console.log(result);
+        }
+    }
+}
+
+discover();

packages/core/src/protocol-interfaces.ts

@@ -59,6 +59,8 @@ export interface ProtocolClient {
     /** this client is requested to perform an "unlink" on the resource with the given URI */
     unlinkResource(form: TD.Form): Promise<void>;
 
+    discoverDirectly(uri: string): Promise<Content>;
+
     subscribeResource(
         form: TD.Form,
         next: (content: Content) => void,

packages/core/src/wot-impl.ts

@@ -19,28 +19,73 @@
 import ExposedThing from "./exposed-thing";
 import ConsumedThing from "./consumed-thing";
 import Helpers from "./helpers";
+import { ThingDescription } from "wot-thing-description-types";
 import { createLoggers } from "./logger";
+import ContentManager from "./content-serdes";
 
 const { debug } = createLoggers("core", "wot-impl");
 
+class ThingDiscoveryProcess implements WoT.ThingDiscoveryProcess {
+    #done = false;
+
+    get done() {
+        return this.#done;
+    }
+
+    #error?: Error;
+
+    get error() {
+        return this.#error;
+    }
+
+    #filter: WoT.ThingFilter;
+
+    constructor(filter?: WoT.ThingFilter) {
+        this.#filter = filter ?? {};
+    }
+
+    filter?: WoT.ThingFilter | undefined;
+
+    [Symbol.asyncIterator](): AsyncIterator<ThingDescription> {
+            throw new Error("Method not implemented.");
+    }
+
+    stop(): void {
+        this.#done = true;
+    }
+}
+
 export default class WoTImpl {
     private srv: Servient;
+
     constructor(srv: Servient) {
         this.srv = srv;
     }
 
     /** @inheritDoc */
     async discover(filter?: WoT.ThingFilter): Promise<WoT.ThingDiscoveryProcess> {
-        throw new Error("not implemented");
+        // TODO: Implement this function
+        return new ThingDiscoveryProcess(filter);
     }
 
     /** @inheritDoc */
     async exploreDirectory(url: string, filter?: WoT.ThingFilter): Promise<WoT.ThingDiscoveryProcess> {
-        throw new Error("not implemented");
+        return new ThingDiscoveryProcess(filter);
     }
 
-    async requestThingDescription(url: string): Promise<WoT.ThingDescription> {
-        throw new Error("not implemented");
+    /** @inheritDoc */
+    async requestThingDescription(url: string): Promise<ThingDescription> {
+        const uriScheme = new URL(url).protocol.split(":")[0];
+        const client = this.srv.getClientFor(uriScheme);
+        const result = await client.discoverDirectly(url);
+
+        const value = ContentManager.contentToValue({ type: result.type, body: await result.toBuffer() }, {});
+
+        if (value instanceof Object) {
+            return value as ThingDescription;
+        }
+
+        throw new Error("Not found.");
     }
 
     /** @inheritDoc */

packages/core/test/ClientTest.ts

@@ -169,6 +169,10 @@ class TDClient implements ProtocolClient {
     public toString(): string {
         return "TDClient";
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("discoverDirectly not implemented.");
+    }
 }
 
 class TDClientFactory implements ProtocolClientFactory {
@@ -239,6 +243,10 @@ class TrapClient implements ProtocolClient {
     }
 
     public setSecurity = (metadata: SecurityScheme[]) => false;
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("discoverDirectly not implemented.");
+    }
 }
 
 class TrapClientFactory implements ProtocolClientFactory {
@@ -306,6 +314,10 @@ class TestProtocolClient implements ProtocolClient {
         this.securitySchemes = securitySchemes;
         return true;
     }
+
+    async discoverDirectly(uri: string): Promise<Content> {
+        throw new Error("discoverDirectly not implemented.");
+    }
 }
 
 @suite("client flow of servient")

tsconfig.json

@@ -1,6 +1,6 @@
 {
     "compilerOptions": {
-        "target": "es6",
+        "target": "es2018",
         "lib": ["dom"],
         "skipLibCheck": false,
         "module": "commonjs",