chore(release): 0.0.2-develop.1 [skip ci]

## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/libresolver/compare/v0.0.1...v0.0.2-develop.1) (2023-07-05)

.github/workflows/ci.yml

@@ -0,0 +1,13 @@
+name: Build/Publish
+
+on:
+    push:
+        branches:
+            - master
+            - develop
+            - develop-*
+
+jobs:
+    main:
+        uses: lumeweb/github-node-deploy-workflow/.github/workflows/main.yml@master
+        secrets: inherit

.presetterrc.json

@@ -0,0 +1,5 @@
+{
+  "preset": [
+    "@lumeweb/node-library-preset"
+  ]
+}

CHANGELOG.md

@@ -0,0 +1 @@
+## [0.0.2-develop.1](https://git.lumeweb.com/LumeWeb/libresolver/compare/v0.0.1...v0.0.2-develop.1) (2023-07-05)

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Lume Web
+Copyright (c) 2022 Hammmer Technologies LLC
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package.json

@@ -0,0 +1,27 @@
+{
+    "name": "@lumeweb/libresolver",
+    "version": "0.0.2-develop.1",
+    "description": "Common code and interfaces for the DNS resolver modules",
+    "main": "lib/index.js",
+    "repository": {
+        "type": "git",
+        "url": "gitea@git.lumeweb.com:LumeWeb/libresolver.git"
+    },
+    "type": "module",
+    "devDependencies": {
+        "@lumeweb/node-library-preset": "^0.2.7",
+        "presetter": "*"
+    },
+    "readme": "ERROR: No README data found!",
+    "scripts": {
+        "prepare": "presetter bootstrap",
+        "build": "run build",
+        "semantic-release": "semantic-release"
+    },
+    "files": [
+        "lib"
+    ],
+    "publishConfig": {
+        "access": "public"
+    }
+}

src/index.ts

@@ -0,0 +1,3 @@
+export * from "./types.js";
+export * from "./util.js";
+export * from "./resolverModule.js";

src/resolverModule.ts

@@ -0,0 +1,69 @@
+import type { DNSResult, ResolverOptions } from "./types.js";
+import { getTld, isPromise } from "./util.js";
+
+declare class ResolverRegistry {
+  get resolvers(): Set<ResolverModule> | Promise<Set<ResolverModule>>;
+  resolve(
+    domain: string,
+    options?: ResolverOptions,
+    bypassCache?: boolean
+  ): Promise<DNSResult>;
+  register(resolver: ResolverModule): void;
+  clear(): void;
+}
+
+export interface ResolverModule {
+  get resolver(): ResolverRegistry;
+  set resolver(value: ResolverRegistry);
+  resolve(
+    domain: string,
+    options: ResolverOptions,
+    bypassCache: boolean
+  ): Promise<DNSResult>;
+
+  getSupportedTlds(): string[];
+  getSupportedTlds(): Promise<string[]>;
+  getSupportedTlds(): any;
+}
+
+// ts-ignore
+export abstract class AbstractResolverModule {
+  constructor(resolver?: ResolverRegistry) {
+    this._resolver = resolver;
+  }
+
+  private _resolver?: ResolverRegistry;
+
+  get resolver(): ResolverRegistry {
+    return this._resolver as ResolverRegistry;
+  }
+
+  set resolver(value: ResolverRegistry) {
+    this._resolver = value;
+  }
+
+  abstract resolve(
+    domain: string,
+    options: ResolverOptions,
+    bypassCache: boolean
+  ): Promise<DNSResult>;
+
+  getSupportedTlds(): string[];
+  getSupportedTlds(): Promise<string[]>;
+  getSupportedTlds(): any {
+    return [];
+  }
+
+  isTldSupported(domain: string): Promise<boolean>;
+  isTldSupported(domain: string): boolean;
+  isTldSupported(domain: string): any {
+    let supported = this.getSupportedTlds() as any;
+    if (isPromise(supported)) {
+      return (supported as Promise<string[]>).then((supported: string[]) => {
+        return supported.includes(getTld(domain));
+      });
+    }
+
+    return (supported as string[]).includes(getTld(domain));
+  }
+}

src/types.ts

@@ -0,0 +1,29 @@
+export interface ResolverOptions {
+  type: string;
+  customType?: string;
+  options?: any;
+}
+
+export interface DNSResult {
+  records: DNSRecord[];
+  error?: Error;
+}
+
+export interface DNSRecord {
+  type: string;
+  customType?: string;
+  value: string;
+}
+const DNS_RECORD_TYPE = {
+  A: "A",
+  CNAME: "CNAME",
+  NS: "NS",
+  CONTENT: "CONTENT",
+  TEXT: "TEXT",
+  ALL: "ALL",
+  CUSTOM: "CUSTOM",
+};
+
+Object.freeze(DNS_RECORD_TYPE);
+
+export { DNS_RECORD_TYPE };

src/util.ts

@@ -0,0 +1,69 @@
+import { DNSRecord, DNSResult } from "./types.js";
+
+export function getTld(domain: string): string {
+  if (domain.includes(".")) {
+    domain = domain.split(".")[domain.split(".").length - 1];
+  }
+
+  return domain;
+}
+
+export function getSld(domain: string): string {
+  if (domain.includes(".")) {
+    domain = domain
+      .split(".")
+      .slice(0, domain.split(".").length - 1)
+      .join(".");
+  }
+
+  return domain;
+}
+
+export function isIp(ip: string) {
+  return /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/.test(
+    ip
+  );
+}
+
+export function isDomain(domain: string) {
+  return /(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]/.test(
+    domain
+  );
+}
+export function resolverEmptyResponse(): DNSResult {
+  return {
+    records: [],
+  };
+}
+
+export function resolverError(e: Error | string): DNSResult {
+  if (!(e instanceof Error)) {
+    e = new Error(e);
+  }
+  return {
+    records: [],
+    error: e,
+  };
+}
+
+export function resolveSuccess(records: DNSRecord[]): DNSResult {
+  return {
+    records,
+  };
+}
+export function normalizeDomain(domain: string): string {
+  return domain.replace(/^\.+|\.+$/g, "").replace(/^\/+|\/+$/g, "");
+}
+export function isPromise(obj: Promise<any>) {
+  return (
+    !!obj &&
+    (typeof obj === "object" || typeof obj === "function") &&
+    typeof obj.then === "function"
+  );
+}
+
+export function ensureUniqueRecords(records: DNSRecord[]) {
+  return [
+    ...new Set(records.map((item: DNSRecord) => JSON.stringify(item))),
+  ].map((item) => JSON.parse(item));
+}