added: more comments, release v2

.github/workflows/publish-jsr.yml

@@ -0,0 +1,18 @@
+name: Publish to jsr.io
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+      - name: Publish package
+        run: npx jsr publish

.github/workflows/test-on-push.yml

@@ -1,4 +1,4 @@
-name: Test
+name: Run tests
 
 on: [push, pull_request]
 

README.md

@@ -12,19 +12,14 @@ Uses Cloudflare or Google DNS, has a built-in list of subdomains to test for and
 * Detects wildcard `*` records
 * Option to specify extra subdomains to check for
 * Provides results in common format, see `DnsRecord`
-* Works in all JavaScript runtimes: NodeJS (uses `dig`), CloudFlare Workers, Browsers, Deno, etc
-
-## v2 (in dev now) breaking changes
-- ESM only
-- `getAllRecords()` renamed to `getAllDnsRecords()`
-- `getNameServers` is removed, use `getDnsRecords(name: string, type = 'NS')`
+* Works in all JavaScript runtimes: Browsers, NodeJS, CloudFlare Workers, Deno, Bun, etc
 
 ## Getting Started
 
 #### Requirements
 
 - `fetch` as a global
-- `dig` command for DNS lookups, if using `node-dig` as resolver. https://linux.die.net/man/1/dig
+- `dig` command for DNS lookups, if using `node-dig` resolver. https://linux.die.net/man/1/dig
 
 #### Installation
 

dist/index.d.ts

@@ -1,12 +1,12 @@
-/** DNS Record object */
+/** DNS Record object, with type, ttl and value */
 export interface DnsRecord {
-    /** Fully qualified domain name */
+    /** Fully qualified domain name (example.com, mail.google.com, analytics.x.com) */
     name: string;
     /** Record type: A, AAAA, CNAME, MX, TXT, etc. */
     type: string;
-    /** Time to live in seconds */
+    /** Time to live (in seconds) for this record */
     ttl: number;
-    /** Record data */
+    /** Record data: IP for A or AAAA, fqdn for CNAME, etc */
     data: string;
 }
 /**
@@ -81,5 +81,6 @@ export declare function parseDnsRecord(record: string | Uint8Array): DnsRecord;
  * @param domain Domain name.
  * @param records Array of DNS records.
  * @param percent Percentage of records with the same data to consider a wildcard.
+ * @returns Array of DNS records with wildcard records grouped as `*.domain`.
  */
 export declare function detectWildcardRecords(domain: string, records: DnsRecord[], percent?: number): DnsRecord[];

dist/index.js

@@ -155,15 +155,16 @@ export function getAllDnsRecordsStream(domain, options = {}) {
     const reqDone = () => {
         // if we have all the records, check for subdomains
         if (--runningChecks === 0) {
+            // check for A,AAAA,CNAME subdomains
             while (subdomainsExtra.length) {
                 const subdomain = subdomainsExtra.shift();
-                //console.log('sub', subdomain, !subdomainsChecked.includes(subdomain))
                 if (subdomain && !subdomainsChecked.includes(subdomain)) {
                     runningChecks++;
                     subdomainsChecked.push(subdomain);
                     getDnsRecords(`${subdomain}.${domain}`, 'A', options.resolver).then(sendRecords);
                 }
             }
+            //todo check for txt records for subdomains
         }
         if (runningChecks === 0) {
             writer.close();
@@ -205,11 +206,18 @@ export function getAllDnsRecordsStream(domain, options = {}) {
             getDnsRecords(domain, 'TXT', options.resolver).then(records => {
                 records.forEach(r => {
                     // extract subdomains from SPF records
+                    // https://datatracker.ietf.org/doc/html/rfc7208
                     if (r.data.includes('v=spf1') && r.data.includes(domain)) {
                         r.data.split(' ').forEach(spf => {
                             if (spf.startsWith('include:') && spf.endsWith(domain)) {
                                 addSubdomain(spf.replace('include:', ''));
                             }
+                            else if (spf.startsWith('a:') && spf.endsWith(domain)) {
+                                addSubdomain(spf.replace('a:', ''));
+                            }
+                            else if (spf.startsWith('mx:') && spf.endsWith(domain)) {
+                                addSubdomain(spf.replace('mx:', ''));
+                            }
                         });
                     }
                 });
@@ -282,6 +290,7 @@ export function parseDnsRecord(record) {
  * @param domain Domain name.
  * @param records Array of DNS records.
  * @param percent Percentage of records with the same data to consider a wildcard.
+ * @returns Array of DNS records with wildcard records grouped as `*.domain`.
  */
 export function detectWildcardRecords(domain, records, percent = 0.15) {
     const sameDataGroup = {};
@@ -299,6 +308,7 @@ export function detectWildcardRecords(domain, records, percent = 0.15) {
             const key = `${record.type}-${record.data}`;
             const sameData = sameDataGroup[key] || 0;
             const recordTypeLength = records.filter(r => r.type === record.type).length;
+            // ?? make the formula easier to understand, already don't know how it works
             if (sameData / recordTypeLength < percent || recordTypeLength < subdomainsRecords.length / 2) {
                 recordsWithWildcard.push(record);
             }

jsr.json

@@ -1,5 +1,5 @@
 {
   "name": "@layered/dns-records",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "exports": "./src/index.ts"
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layered/dns-records",
-  "version": "2.0.0-beta.10",
+  "version": "2.0.0",
   "description": "Discover publicly available DNS Records for a domain",
   "type": "module",
   "keywords": [

src/index.ts

@@ -1,15 +1,15 @@
 import { toASCII } from 'punycode'
 import { subdomainsRecords } from './subdomains.js'
 
-/** DNS Record object */
+/** DNS Record object, with type, ttl and value */
 export interface DnsRecord {
-	/** Fully qualified domain name */
+	/** Fully qualified domain name (example.com, mail.google.com, analytics.x.com) */
 	name: string
 	/** Record type: A, AAAA, CNAME, MX, TXT, etc. */
 	type: string
-	/** Time to live in seconds */
+	/** Time to live (in seconds) for this record */
 	ttl: number
-	/** Record data */
+	/** Record data: IP for A or AAAA, fqdn for CNAME, etc */
 	data: string
 }
 
@@ -210,16 +210,19 @@ export function getAllDnsRecordsStream(domain: string, options: Partial<GetAllDn
 	const reqDone = () => {
 		// if we have all the records, check for subdomains
 		if (--runningChecks === 0) {
+
+			// check for A,AAAA,CNAME subdomains
 			while (subdomainsExtra.length) {
 				const subdomain = subdomainsExtra.shift()
-				//console.log('sub', subdomain, !subdomainsChecked.includes(subdomain))
 
 				if (subdomain && !subdomainsChecked.includes(subdomain)) {
 					runningChecks++
 					subdomainsChecked.push(subdomain)
 					getDnsRecords(`${subdomain}.${domain}`, 'A', options.resolver).then(sendRecords)
 				}
 			}
+
+			//todo check for txt records for subdomains
 		}
 
 		if (runningChecks === 0) {
@@ -362,6 +365,7 @@ export function parseDnsRecord(record: string|Uint8Array): DnsRecord {
  * @param domain Domain name.
  * @param records Array of DNS records.
  * @param percent Percentage of records with the same data to consider a wildcard.
+ * @returns Array of DNS records with wildcard records grouped as `*.domain`.
  */
 export function detectWildcardRecords(domain: string, records: DnsRecord[], percent = 0.15): DnsRecord[] {
 	const sameDataGroup: { [key: string]: number } = {}
@@ -383,6 +387,7 @@ export function detectWildcardRecords(domain: string, records: DnsRecord[], perc
 			const sameData = sameDataGroup[key] || 0
 			const recordTypeLength = records.filter(r => r.type === record.type).length
 
+			// ?? make the formula easier to understand, already don't know how it works
 			if (sameData / recordTypeLength < percent || recordTypeLength < subdomainsRecords.length / 2) {
 				recordsWithWildcard.push(record)
 			} else if (!wildcardsFound.includes(key)) {