@blockcore/dns 0.0.4 → 0.0.7

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,17 +1,12 @@
-import { BlockcoreDnsOptions, DnsListEntry, ServiceListEntry } from './types.js';
+import { DnsListEntry, ServiceListEntry } from './types.js';
 export declare class BlockcoreDns {
-    private options;
-    static defaultOptions: BlockcoreDnsOptions;
-    static create(): BlockcoreDns;
+    /** Call this to have data to provide an instance of the Blockcore DNS. */
+    static getDnsServers(): Promise<DnsListEntry[]>;
     private activeServer?;
-    constructor(options?: BlockcoreDnsOptions);
+    constructor(nameserver: string);
     setActiveServer(url: string): void;
-    getDnsServers(): Promise<DnsListEntry[]>;
     getServicesByType(service: 'Indexer' | 'Explorer'): Promise<ServiceListEntry[]>;
     getServicesByTypeAndNetwork(service: 'Indexer' | 'Explorer', symbol: string): Promise<ServiceListEntry[]>;
     getServicesByNetwork(symbol: string): Promise<ServiceListEntry[]>;
     getExternalIP(): Promise<string>;
-    private fetchText;
-    private fetchJson;
-    private fetchUrl;
 }

package/lib/BlockcoreDns.js

@@ -1,74 +1,37 @@
-import fetch from 'node-fetch';
+import { WebRequest } from './Request.js';
 export class BlockcoreDns {
-    constructor(options = BlockcoreDns.defaultOptions) {
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: options
-        });
+    constructor(nameserver) {
         Object.defineProperty(this, "activeServer", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        this.setActiveServer(nameserver);
     }
-    static create() {
-        const dns = new BlockcoreDns();
-        return dns;
+    /** Call this to have data to provide an instance of the Blockcore DNS. */
+    static 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 getDnsServers() {
-        const url = `${this.options.baseUrl}/services/DNS.json`;
-        const servers = await this.fetchJson(url);
-        return servers;
-    }
     async getServicesByType(service) {
         const url = `${this.activeServer}/api/dns/services/service/${service}`;
-        return await this.fetchJson(url);
+        return await WebRequest.fetchJson(url);
     }
     async getServicesByTypeAndNetwork(service, symbol) {
         const url = `${this.activeServer}/api/dns/services/symbol/${symbol}/service/${service}`;
-        return await this.fetchJson(url);
+        return await WebRequest.fetchJson(url);
     }
     async getServicesByNetwork(symbol) {
         const url = `${this.activeServer}/api/dns/services/symbol/${symbol}`;
-        return await this.fetchJson(url);
+        return await WebRequest.fetchJson(url);
     }
     async getExternalIP() {
         const url = `${this.activeServer}/api/dns/ipaddress`;
-        return await this.fetchText(url);
-    }
-    async fetchText(url) {
-        const response = await this.fetchUrl(url);
-        return response.text();
-    }
-    async fetchJson(url) {
-        const response = await this.fetchUrl(url);
-        return response.json();
-    }
-    async fetchUrl(url) {
-        return await fetch(url, {
-            method: 'GET',
-            // mode: 'cors',
-            // cache: 'no-cache',
-            // credentials: 'same-origin',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            redirect: 'follow',
-            referrerPolicy: 'no-referrer',
-        });
+        return await WebRequest.fetchText(url);
     }
 }
-Object.defineProperty(BlockcoreDns, "defaultOptions", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: {
-        baseUrl: 'https://chains.blockcore.net',
-    }
-});

package/lib/Request.d.ts

@@ -0,0 +1,5 @@
+export declare class WebRequest {
+    static fetchText(url: string): Promise<string>;
+    static fetchJson<T>(url: string): Promise<T>;
+    static fetchUrl(url: string): Promise<Response>;
+}

package/lib/Request.js

@@ -0,0 +1,20 @@
+export class WebRequest {
+    static async fetchText(url) {
+        const response = await WebRequest.fetchUrl(url);
+        return response.text();
+    }
+    static async fetchJson(url) {
+        const response = await WebRequest.fetchUrl(url);
+        return response.json();
+    }
+    static async fetchUrl(url) {
+        return await fetch(url, {
+            method: 'GET',
+            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/lib/types.d.ts

@@ -9,6 +9,3 @@ export interface ServiceListEntry {
     ttl: number;
     online: boolean;
 }
-export interface BlockcoreDnsOptions {
-    baseUrl: string;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blockcore/dns",
-  "version": "0.0.4",
+  "version": "0.0.7",
   "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,10 +51,5 @@
     "nodeArguments": [
       "--loader=ts-node/esm"
     ]
-  },
-  "dependencies": {
-    "@blockcore/dns": "^0.0.3",
-    "@blockcore/identity": "^0.0.1",
-    "node-fetch": "^3.2.9"
   }
 }