dist/index.d.ts

@@ -1,3 +1,3 @@
-import { ResolverModuleConstructor } from "./resolverRegistry.js";
+import type { ResolverModuleConstructor } from "@lumeweb/resolver-common";
 export declare function setup(rm: ResolverModuleConstructor): void;
 export * from "./resolverRegistry.js";

dist/index.js

@@ -1,17 +1,18 @@
 import { addHandler, handleMessage } from "libkmodule";
-import { ResolverRegistry, } from "./resolverRegistry.js";
+import { register } from "@lumeweb/kernel-dns-client";
+import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
+import { ResolverRegistry } from "./resolverRegistry.js";
 import { DNS_RECORD_TYPE } from "@lumeweb/libresolver";
-import { dnsClient } from "./client.js";
 let resolver;
 export function setup(rm) {
     addHandler("resolve", handleResolve);
     addHandler("register", handleRegister);
     addHandler("getSupportedTlds", handleGetSupportedTlds);
     onmessage = handleMessage;
-    resolver = new rm(new ResolverRegistry());
+    resolver = new rm(new ResolverRegistry(new RpcNetwork()));
 }
 async function handleRegister(aq) {
-    await dnsClient.register();
+    await register();
     aq.respond();
 }
 async function handleResolve(aq) {

dist/resolverRegistry.d.ts

@@ -1,24 +1,17 @@
-import {
+import { DNSResult, ResolverOptions } from "@lumeweb/resolver-common";
-  DNSResult,
+import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
-  ResolverOptions,
-  ResolverModuleConstructor as ResolverModuleConstructorBase,
-} from "@lumeweb/libresolver";
-import { Client } from "@lumeweb/libkernel-universal";
-export interface ResolverModuleConstructor
-  extends ResolverModuleConstructorBase {
-  new (resolver: ResolverRegistry): ResolverModule;
-}
 export declare class ResolverRegistry {
+  private _rpcNetwork;
+  constructor(network: RpcNetwork);
+  get rpcNetwork(): RpcNetwork;
   get resolvers(): Promise<Set<ResolverModule>>;
   resolve(
     domain: string,
     options?: ResolverOptions,
     bypassCache?: boolean
   ): Promise<DNSResult>;
-  register(resolver: ResolverModule): void;
-  clear(): void;
 }
-export declare class ResolverModule extends Client {
+export declare class ResolverModule {
   private resolver;
   private domain;
   constructor(resolver: ResolverRegistry, domain: string);
@@ -29,3 +22,4 @@ export declare class ResolverModule extends Client {
   ): Promise<DNSResult>;
   getSupportedTlds(): Promise<string[]>;
 }
+export { RpcNetwork };

dist/resolverRegistry.js

@@ -1,49 +1,59 @@
-import { DNS_RECORD_TYPE, resolverError, } from "@lumeweb/libresolver";
+import { DNS_RECORD_TYPE, resolverError, } from "@lumeweb/resolver-common";
-import { Client, factory } from "@lumeweb/libkernel-universal";
+import { getResolvers, resolve } from "@lumeweb/kernel-dns-client";
-import { dnsClient } from "./client.js";
+import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
+import { callModule } from "libkmodule";
 export class ResolverRegistry {
+    _rpcNetwork;
+    constructor(network) {
+        this._rpcNetwork = network;
+    }
+    get rpcNetwork() {
+        return this._rpcNetwork;
+    }
     get resolvers() {
-        return dnsClient
+        return getResolvers()
-            .getResolvers()
-            .then((resolvers) => {
-            return new Set(resolvers.map((resolver) => factory(ResolverModule, resolver)(this, resolver)));
-        })
             .catch(() => {
             return new Set();
+        })
+            .then((resolvers) => {
+            return new Set(resolvers.map((resolver) => new ResolverModule(this, resolver)));
         });
     }
     async resolve(domain, options = { type: DNS_RECORD_TYPE.CONTENT }, bypassCache = false) {
+        let result;
         try {
-            return dnsClient.resolve(domain, options, bypassCache);
+            result = await resolve(domain, options, bypassCache);
         }
         catch (e) {
             return resolverError(e);
         }
+        return result;
     }
-    register(resolver) { }
-    clear() { }
 }
-export class ResolverModule extends Client {
+export class ResolverModule {
     resolver;
     domain;
     constructor(resolver, domain) {
-        super();
         this.resolver = resolver;
         this.domain = domain;
     }
     async resolve(domain, options, bypassCache) {
-        try {
+        const [ret, err] = await callModule(this.domain, "resolve", {
-            return this.callModuleReturn("resolve", {
+            domain,
-                domain,
+            options,
-                options,
+            bypassCache,
-                bypassCache,
+        });
-            });
+        if (err) {
-        }
+            return resolverError(err);
-        catch (e) {
-            return resolverError(e);
         }
+        return ret;
     }
     async getSupportedTlds() {
-        return this.callModuleReturn("getSupportedTlds");
+        const [ret, err] = await callModule(this.domain, "getSupportedTlds");
+        if (err) {
+            throw new Error(err);
+        }
+        return ret;
     }
 }
+export { RpcNetwork };

package.json

@@ -3,17 +3,13 @@
     "version": "0.1.0",
     "main": "dist/index.js",
     "dependencies": {
-        "@lumeweb/kernel-dns-client": "git+https://git.lumeweb.com/LumeWeb/kernel-dns-client.git",
+        "@lumeweb/kernel-dns-client": "https://github.com/LumeWeb/kernel-dns-client.git",
-        "@lumeweb/kernel-libresolver": "git+https://git.lumeweb.com/LumeWeb/kernel-libresolver.git",
+        "@lumeweb/kernel-rpc-client": "https://github.com/LumeWeb/kernel-rpc-client.git",
-        "@lumeweb/kernel-rpc-client": "git+https://git.lumeweb.com/LumeWeb/kernel-rpc-client.git",
+        "@lumeweb/libresolver": "https://github.com/LumeWeb/libresolver.git",
-        "@lumeweb/libkernel-universal": "git+https://git.lumeweb.com/LumeWeb/libkernel-universal.git",
+        "libkmodule": "^0.2.51"
-        "@lumeweb/libresolver": "git+https://git.lumeweb.com/LumeWeb/libresolver.git",
-        "libkmodule": "^0.2.53"
     },
     "devDependencies": {
-        "@lumeweb/relay-types": "git+https://git.lumeweb.com/LumeWeb/relay-types.git",
+        "@lumeweb/relay-types": "https://github.com/LumeWeb/relay-types.git",
-        "@types/node": "^18.14.0",
+        "@types/node": "^18.7.14"
-        "prettier": "^2.8.4",
-        "typescript": "^4.9.5"
     }
 }

src/client.ts

@@ -1,3 +0,0 @@
-import { createClient } from "@lumeweb/kernel-dns-client";
-
-export const dnsClient = createClient();

src/index.ts

@@ -1,13 +1,13 @@
 import { addHandler, ActiveQuery, handleMessage } from "libkmodule";
-
+import { register } from "@lumeweb/kernel-dns-client";
-import type { DNSResult } from "@lumeweb/libresolver";
+import type {
-import {
+  DNSResult,
-  ResolverModule,
   ResolverModuleConstructor,
-  ResolverRegistry,
+  ResolverModule,
-} from "./resolverRegistry.js";
+} from "@lumeweb/resolver-common";
+import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
+import { ResolverRegistry } from "./resolverRegistry.js";
 import { DNS_RECORD_TYPE } from "@lumeweb/libresolver";
-import { dnsClient } from "./client.js";
 
 let resolver: ResolverModule;
 
@@ -16,11 +16,11 @@ export function setup(rm: ResolverModuleConstructor) {
   addHandler("register", handleRegister);
   addHandler("getSupportedTlds", handleGetSupportedTlds);
   onmessage = handleMessage;
-  resolver = new rm(new ResolverRegistry());
+  resolver = new rm(new ResolverRegistry(new RpcNetwork()) as any);
 }
 
 async function handleRegister(aq: ActiveQuery) {
-  await dnsClient.register();
+  await register();
   aq.respond();
 }
 

src/resolverRegistry.ts

@@ -3,29 +3,31 @@ import {
   ResolverOptions,
   DNS_RECORD_TYPE,
   resolverError,
-  ResolverModuleConstructor as ResolverModuleConstructorBase,
+} from "@lumeweb/resolver-common";
-} from "@lumeweb/libresolver";
+import { getResolvers, resolve } from "@lumeweb/kernel-dns-client";
-import { Client, factory } from "@lumeweb/libkernel-universal";
+import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
-import { dnsClient } from "./client.js";
+import { callModule } from "libkmodule";
-
-export interface ResolverModuleConstructor
-  extends ResolverModuleConstructorBase {
-  new (resolver: ResolverRegistry): ResolverModule;
-}
 
 export class ResolverRegistry {
+  private _rpcNetwork: RpcNetwork;
+
+  constructor(network: RpcNetwork) {
+    this._rpcNetwork = network;
+  }
+
+  get rpcNetwork(): RpcNetwork {
+    return this._rpcNetwork;
+  }
+
   get resolvers(): Promise<Set<ResolverModule>> {
-    return dnsClient
+    return getResolvers()
-      .getResolvers()
-      .then((resolvers: string[]) => {
-        return new Set(
-          resolvers.map((resolver) =>
-            factory<ResolverModule>(ResolverModule, resolver)(this, resolver)
-          )
-        );
-      })
       .catch(() => {
         return new Set();
+      })
+      .then((resolvers: string[]) => {
+        return new Set(
+          resolvers.map((resolver) => new ResolverModule(this, resolver))
+        );
       });
   }
 
@@ -34,22 +36,23 @@ export class ResolverRegistry {
     options: ResolverOptions = { type: DNS_RECORD_TYPE.CONTENT },
     bypassCache: boolean = false
   ): Promise<DNSResult> {
+    let result: DNSResult;
+
     try {
-      return dnsClient.resolve(domain, options, bypassCache);
+      result = await resolve(domain, options, bypassCache);
     } catch (e: any) {
       return resolverError(e);
     }
+
+    return result;
   }
-  public register(resolver: ResolverModule): void {}
-  public clear(): void {}
 }
 
-export class ResolverModule extends Client {
+export class ResolverModule {
   private resolver: ResolverRegistry;
   private domain: string;
 
   constructor(resolver: ResolverRegistry, domain: string) {
-    super();
     this.resolver = resolver;
     this.domain = domain;
   }
@@ -59,17 +62,25 @@ export class ResolverModule extends Client {
     options: ResolverOptions,
     bypassCache: boolean
   ): Promise<DNSResult> {
-    try {
+    const [ret, err] = await callModule(this.domain, "resolve", {
-      return this.callModuleReturn("resolve", {
+      domain,
-        domain,
+      options,
-        options,
+      bypassCache,
-        bypassCache,
+    });
-      });
+    if (err) {
-    } catch (e) {
+      return resolverError(err);
-      return resolverError(e as Error);
     }
+
+    return ret;
   }
   async getSupportedTlds(): Promise<string[]> {
-    return this.callModuleReturn("getSupportedTlds");
+    const [ret, err] = await callModule(this.domain, "getSupportedTlds");
+    if (err) {
+      throw new Error(err);
+    }
+
+    return ret;
   }
 }
+
+export { RpcNetwork };