*Refactor to set the registry via getter vs passing as a constructor

src/index.ts

@@ -1,22 +1,27 @@
 import { addHandler, ActiveQuery, handleMessage } from "libkmodule";
 
-import type { DNSResult } from "@lumeweb/libresolver";
+import type {
-import {
+  DNSResult,
-  ResolverModule,
+  ResolverModule as ResolverModuleBase,
-  ResolverModuleConstructor,
+} from "@lumeweb/libresolver";
-  ResolverRegistry,
-} from "./resolverRegistry.js";
 import { DNS_RECORD_TYPE } from "@lumeweb/libresolver";
 import { dnsClient } from "./client.js";
+import { DnsClient } from "@lumeweb/kernel-dns-client";
 
 let resolver: ResolverModule;
 
-export function setup(rm: ResolverModuleConstructor) {
+interface ResolverModule extends ResolverModuleBase {
+  get resolver(): DnsClient;
+  set resolver(value: DnsClient);
+}
+
+export function setup(rm: ResolverModule) {
   addHandler("resolve", handleResolve);
   addHandler("register", handleRegister);
   addHandler("getSupportedTlds", handleGetSupportedTlds);
   onmessage = handleMessage;
-  resolver = new rm(new ResolverRegistry());
+  resolver = rm;
+  resolver.resolver = dnsClient;
 }
 
 async function handleRegister(aq: ActiveQuery) {
@@ -54,7 +59,6 @@ function handleGetSupportedTlds(aq: ActiveQuery) {
   aq.respond(resolver.getSupportedTlds());
 }
 
-export * from "./resolverRegistry.js";
 export * from "@lumeweb/libresolver/dist/util.js";
 export * from "@lumeweb/libresolver/dist/types.js";
 export { AbstractResolverModule } from "@lumeweb/libresolver/dist/resolverModule.js";

src/resolverRegistry.ts

@@ -1,75 +0,0 @@
-import {
-  DNSResult,
-  ResolverOptions,
-  DNS_RECORD_TYPE,
-  resolverError,
-  ResolverModuleConstructor as ResolverModuleConstructorBase,
-} from "@lumeweb/libresolver";
-import { Client, factory } from "@lumeweb/libkernel-universal";
-import { dnsClient } from "./client.js";
-
-export interface ResolverModuleConstructor
-  extends ResolverModuleConstructorBase {
-  new (resolver: ResolverRegistry): ResolverModule;
-}
-
-export class ResolverRegistry {
-  get resolvers(): Promise<Set<ResolverModule>> {
-    return dnsClient
-      .getResolvers()
-      .then((resolvers: string[]) => {
-        return new Set(
-          resolvers.map((resolver) =>
-            factory<ResolverModule>(ResolverModule, resolver)(this, resolver)
-          )
-        );
-      })
-      .catch(() => {
-        return new Set();
-      });
-  }
-
-  public async resolve(
-    domain: string,
-    options: ResolverOptions = { type: DNS_RECORD_TYPE.CONTENT },
-    bypassCache: boolean = false
-  ): Promise<DNSResult> {
-    try {
-      return dnsClient.resolve(domain, options, bypassCache);
-    } catch (e: any) {
-      return resolverError(e);
-    }
-  }
-  public register(resolver: ResolverModule): void {}
-  public clear(): void {}
-}
-
-export class ResolverModule extends Client {
-  private resolver: ResolverRegistry;
-  private domain: string;
-
-  constructor(resolver: ResolverRegistry, domain: string) {
-    super();
-    this.resolver = resolver;
-    this.domain = domain;
-  }
-
-  async resolve(
-    domain: string,
-    options: ResolverOptions,
-    bypassCache: boolean
-  ): Promise<DNSResult> {
-    try {
-      return this.callModuleReturn("resolve", {
-        domain,
-        options,
-        bypassCache,
-      });
-    } catch (e) {
-      return resolverError(e as Error);
-    }
-  }
-  async getSupportedTlds(): Promise<string[]> {
-    return this.callModuleReturn("getSupportedTlds");
-  }
-}