*Update dist

*remove rpc code for now

dist/index.d.ts

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

dist/index.js

@@ -1,18 +1,17 @@
 import { addHandler, handleMessage } from "libkmodule";
-import { register } from "@lumeweb/kernel-dns-client";
+import { ResolverRegistry, } from "./resolverRegistry.js";
-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(new RpcNetwork()));
+    resolver = new rm(new ResolverRegistry());
 }
 async function handleRegister(aq) {
-    await register();
+    await dnsClient.register();
     aq.respond();
 }
 async function handleResolve(aq) {

dist/resolverRegistry.d.ts

@@ -1,17 +1,24 @@
-import { DNSResult, ResolverOptions } from "@lumeweb/resolver-common";
+import {
-import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
+  DNSResult,
+  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 {
+export declare class ResolverModule extends Client {
   private resolver;
   private domain;
   constructor(resolver: ResolverRegistry, domain: string);
@@ -22,4 +29,3 @@ export declare class ResolverModule {
   ): Promise<DNSResult>;
   getSupportedTlds(): Promise<string[]>;
 }
-export { RpcNetwork };

dist/resolverRegistry.js

@@ -1,59 +1,49 @@
-import { DNS_RECORD_TYPE, resolverError, } from "@lumeweb/resolver-common";
+import { DNS_RECORD_TYPE, resolverError, } 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 class ResolverRegistry {
-    _rpcNetwork;
-    constructor(network) {
-        this._rpcNetwork = network;
-    }
-    get rpcNetwork() {
-        return this._rpcNetwork;
-    }
     get resolvers() {
-        return getResolvers()
+        return dnsClient
+            .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 {
-            result = await resolve(domain, options, bypassCache);
+            return dnsClient.resolve(domain, options, bypassCache);
         }
         catch (e) {
             return resolverError(e);
         }
-        return result;
     }
+    register(resolver) { }
+    clear() { }
 }
-export class ResolverModule {
+export class ResolverModule extends Client {
     resolver;
     domain;
     constructor(resolver, domain) {
+        super();
         this.resolver = resolver;
         this.domain = domain;
     }
     async resolve(domain, options, bypassCache) {
-        const [ret, err] = await callModule(this.domain, "resolve", {
+        try {
-            domain,
+            return this.callModuleReturn("resolve", {
-            options,
+                domain,
-            bypassCache,
+                options,
-        });
+                bypassCache,
-        if (err) {
+            });
-            return resolverError(err);
+        }
+        catch (e) {
+            return resolverError(e);
         }
-        return ret;
     }
     async getSupportedTlds() {
-        const [ret, err] = await callModule(this.domain, "getSupportedTlds");
+        return this.callModuleReturn("getSupportedTlds");
-        if (err) {
-            throw new Error(err);
-        }
-        return ret;
     }
 }
-export { RpcNetwork };

package.json

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

src/client.ts

@@ -0,0 +1,3 @@
+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 {
+import type { DNSResult } from "@lumeweb/libresolver";
-  DNSResult,
+import {
-  ResolverModuleConstructor,
   ResolverModule,
-} from "@lumeweb/resolver-common";
+  ResolverModuleConstructor,
-import { RpcNetwork } from "@lumeweb/kernel-rpc-client";
+  ResolverRegistry,
-import { ResolverRegistry } from "./resolverRegistry.js";
+} 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(new RpcNetwork()) as any);
+  resolver = new rm(new ResolverRegistry());
 }
 
 async function handleRegister(aq: ActiveQuery) {
-  await register();
+  await dnsClient.register();
   aq.respond();
 }
 

src/resolverRegistry.ts

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