@blockcore/dns 0.0.5 → 0.0.8

package/README.md

@@ -30,20 +30,18 @@ npm install @blockcore/dns
 ```ts
 import { BlockcoreDns } from '@blockcore/dns';
 
-let dns = new BlockcoreDns();
-let servers = await dns.getDnsServers();
+let dns = new BlockcoreDns('https://ns.blockcore.net');
+let indexers = await dns.getServicesByType('Indexer');
 ```
 
-After getting the servers, either you can loop all of them or pick a single one:
+You can retrieve the public known nameservers and use those instead of manually specifying server:
 
 ```ts
-let server = servers[0];
-
-dns.setActiveServer(dnsServer.url);
+let dnsServers = await BlockcoreDns.getDnsServers();
+dns.setActiveServer(dnsServers[0].url);
 
 await dns.getServicesByType('Indexer');
 await dns.getServicesByNetwork('CITY');
 await dns.getServicesByTypeAndNetwork('Indexer', 'CITY');
 await dns.getExternalIP();
 ```
-

package/lib/BlockcoreDns.d.ts

@@ -1,12 +1,16 @@
 import { DnsListEntry, ServiceListEntry } from './types.js';
+/** The BlockcoreDns class will give you access to all known nameservers and all services registered with those nameservers. */
 export declare class BlockcoreDns {
-    /** Call this to have data to provide an instance of the Blockcore DNS. */
-    static getDnsServers(): Promise<DnsListEntry[]>;
-    private activeServer?;
-    constructor(nameserver: string);
-    setActiveServer(url: string): void;
-    getServicesByType(service: 'Indexer' | 'Explorer'): Promise<ServiceListEntry[]>;
-    getServicesByTypeAndNetwork(service: 'Indexer' | 'Explorer', symbol: string): Promise<ServiceListEntry[]>;
-    getServicesByNetwork(symbol: string): Promise<ServiceListEntry[]>;
-    getExternalIP(): Promise<string>;
+    private nameservers;
+    private services;
+    private dns;
+    constructor();
+    private getDnsServers;
+    getNameServers(): DnsListEntry[];
+    getOnlineServicesByNetwork(network: string): ServiceListEntry[];
+    getServices(): ServiceListEntry[];
+    /** Attempts to load the latest status of all services from all known nameservers. This method can be called
+     * at intervals to ensure latest status is available.
+     */
+    load(): Promise<void>;
 }

package/lib/BlockcoreDns.js

@@ -1,37 +1,57 @@
 import { WebRequest } from './Request.js';
+import { BlockcoreDnsClient } from './BlockcoreDnsClient.js';
+/** The BlockcoreDns class will give you access to all known nameservers and all services registered with those nameservers. */
 export class BlockcoreDns {
-    constructor(nameserver) {
-        Object.defineProperty(this, "activeServer", {
+    constructor() {
+        Object.defineProperty(this, "nameservers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "services", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "dns", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        this.setActiveServer(nameserver);
+        this.dns = new BlockcoreDnsClient('');
     }
-    /** Call this to have data to provide an instance of the Blockcore DNS. */
-    static async getDnsServers() {
+    async getDnsServers() {
         const url = `https://chains.blockcore.net/services/DNS.json`;
         const servers = await WebRequest.fetchJson(url);
         return servers;
     }
-    setActiveServer(url) {
-        this.activeServer = url;
-    }
-    async getServicesByType(service) {
-        const url = `${this.activeServer}/api/dns/services/service/${service}`;
-        return await WebRequest.fetchJson(url);
+    getNameServers() {
+        return this.nameservers;
     }
-    async getServicesByTypeAndNetwork(service, symbol) {
-        const url = `${this.activeServer}/api/dns/services/symbol/${symbol}/service/${service}`;
-        return await WebRequest.fetchJson(url);
+    getOnlineServicesByNetwork(network) {
+        return this.services.filter((s) => s.symbol === network && s.online === true);
     }
-    async getServicesByNetwork(symbol) {
-        const url = `${this.activeServer}/api/dns/services/symbol/${symbol}`;
-        return await WebRequest.fetchJson(url);
+    getServices() {
+        return this.services;
     }
-    async getExternalIP() {
-        const url = `${this.activeServer}/api/dns/ipaddress`;
-        return await WebRequest.fetchText(url);
+    /** Attempts to load the latest status of all services from all known nameservers. This method can be called
+     * at intervals to ensure latest status is available.
+     */
+    async load() {
+        this.nameservers = await this.getDnsServers();
+        const servicesMap = new Map();
+        for (let i = 0; i < this.nameservers.length; i++) {
+            const nameserver = this.nameservers[i];
+            if (!nameserver) {
+                continue;
+            }
+            this.dns.setActiveServer(nameserver.url);
+            const services = await this.dns.getServicesByType('Indexer');
+            services.forEach((item) => servicesMap.set(item.domain, { ...servicesMap.get(item.domain), ...item }));
+        }
+        this.services = Array.from(servicesMap.values());
     }
 }

package/lib/BlockcoreDnsClient.d.ts

@@ -0,0 +1,10 @@
+import { ServiceListEntry } from './types.js';
+export declare class BlockcoreDnsClient {
+    private activeServer?;
+    constructor(nameserver: string);
+    setActiveServer(url: string): void;
+    getServicesByType(service: 'Indexer' | 'Explorer'): Promise<ServiceListEntry[]>;
+    getServicesByTypeAndNetwork(service: 'Indexer' | 'Explorer', symbol: string): Promise<ServiceListEntry[]>;
+    getServicesByNetwork(symbol: string): Promise<ServiceListEntry[]>;
+    getExternalIP(): Promise<string>;
+}

package/lib/BlockcoreDnsClient.js

@@ -0,0 +1,31 @@
+import { WebRequest } from './Request.js';
+export class BlockcoreDnsClient {
+    constructor(nameserver) {
+        Object.defineProperty(this, "activeServer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.setActiveServer(nameserver);
+    }
+    setActiveServer(url) {
+        this.activeServer = url;
+    }
+    async getServicesByType(service) {
+        const url = `${this.activeServer}/api/dns/services/service/${service}`;
+        return await WebRequest.fetchJson(url);
+    }
+    async getServicesByTypeAndNetwork(service, symbol) {
+        const url = `${this.activeServer}/api/dns/services/symbol/${symbol}/service/${service}`;
+        return await WebRequest.fetchJson(url);
+    }
+    async getServicesByNetwork(symbol) {
+        const url = `${this.activeServer}/api/dns/services/symbol/${symbol}`;
+        return await WebRequest.fetchJson(url);
+    }
+    async getExternalIP() {
+        const url = `${this.activeServer}/api/dns/ipaddress`;
+        return await WebRequest.fetchText(url);
+    }
+}

package/lib/Request.d.ts

@@ -1,4 +1,3 @@
-import { Response } from 'node-fetch';
 export declare class WebRequest {
     static fetchText(url: string): Promise<string>;
     static fetchJson<T>(url: string): Promise<T>;

package/lib/Request.js

@@ -1,4 +1,3 @@
-import fetch from 'node-fetch';
 export class WebRequest {
     static async fetchText(url) {
         const response = await WebRequest.fetchUrl(url);
@@ -11,12 +10,9 @@ export class WebRequest {
     static async fetchUrl(url) {
         return await fetch(url, {
             method: 'GET',
-            // mode: 'cors',
-            // cache: 'no-cache',
-            // credentials: 'same-origin',
-            headers: {
-                'Content-Type': 'application/json',
-            },
+            mode: 'cors',
+            cache: 'no-cache',
+            credentials: 'omit',
             redirect: 'follow',
             referrerPolicy: 'no-referrer',
         });

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export * from './BlockcoreDns.js';
+export * from './Request.js';
 export * from './types.js';

package/lib/index.js

@@ -1,2 +1,3 @@
 export * from './BlockcoreDns.js';
+export * from './Request.js';
 export * from './types.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcore/dns",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "type": "module",
   "exports": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -8,13 +8,14 @@
     "lib/**/*"
   ],
   "engines": {
-    "node": ">=14.16"
+    "node": ">=18.*"
   },
   "scripts": {
     "build": "tsc",
     "lint": "eslint .",
     "test": "npm run lint && ava",
-    "version": "node -p \"require('./package.json').version\""
+    "version": "node -p \"require('./package.json').version\"",
+    "changelog": "conventional-changelog -i CHANGELOG.md -s -r 0 && git add CHANGELOG.md"
   },
   "repository": {
     "type": "git",
@@ -50,9 +51,5 @@
     "nodeArguments": [
       "--loader=ts-node/esm"
     ]
-  },
-  "dependencies": {
-    "@blockcore/identity": "^0.0.1",
-    "node-fetch": "^3.2.9"
   }
 }