@stacksjs/dns 0.59.11 → 0.61.1

package/dist/index.js

@@ -2,22 +2,26 @@
 // src/drivers/aws.ts
 import {Route53} from "@aws-sdk/client-route-53";
 import {Route53Domains} from "@aws-sdk/client-route-53-domains";
-import {err, handleError, ok} from "@stacksjs/error-handling";
-import {log} from "@stacksjs/logging";
 import {runAction} from "@stacksjs/actions";
-import {fs} from "@stacksjs/storage";
 import {config as config2} from "@stacksjs/config";
-import {path as p} from "@stacksjs/path";
 import {Action} from "@stacksjs/enums";
+import {err, handleError, ok} from "@stacksjs/error-handling";
+import {log} from "@stacksjs/logging";
+import {path as p} from "@stacksjs/path";
+import {fs} from "@stacksjs/storage";
 async function deleteHostedZone(domainName) {
   const route53 = new Route53;
-  const hostedZones = await route53.listHostedZonesByName({ DNSName: domainName });
+  const hostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName
+  });
   if (!hostedZones || !hostedZones.HostedZones)
     return err(`No hosted zones found for domain: ${domainName}`);
   const hostedZone = hostedZones.HostedZones.find((zone) => zone.Name === `${domainName}.`);
   if (!hostedZone)
     return err(`Hosted Zone not found for domain: ${domainName}`);
-  const recordSets = await route53.listResourceRecordSets({ HostedZoneId: hostedZone.Id });
+  const recordSets = await route53.listResourceRecordSets({
+    HostedZoneId: hostedZone.Id
+  });
   if (!recordSets || !recordSets.ResourceRecordSets)
     return err(`No DNS records found for domain: ${domainName}`);
   for (const recordSet of recordSets.ResourceRecordSets) {
@@ -25,10 +29,12 @@ async function deleteHostedZone(domainName) {
       await route53.changeResourceRecordSets({
         HostedZoneId: hostedZone.Id,
         ChangeBatch: {
-          Changes: [{
-            Action: "DELETE",
-            ResourceRecordSet: recordSet
-          }]
+          Changes: [
+            {
+              Action: "DELETE",
+              ResourceRecordSet: recordSet
+            }
+          ]
         }
       });
     }
@@ -39,13 +45,17 @@ async function deleteHostedZone(domainName) {
 }
 async function deleteHostedZoneRecords(domainName) {
   const route53 = new Route53;
-  const hostedZones = await route53.listHostedZonesByName({ DNSName: domainName });
+  const hostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName
+  });
   if (!hostedZones || !hostedZones.HostedZones)
     return err(`No hosted zones found for domain: ${domainName}`);
   const hostedZone = hostedZones.HostedZones.find((zone) => zone.Name === `${domainName}.`);
   if (!hostedZone)
     return err(`Hosted Zone not found for domain: ${domainName}`);
-  const recordSets = await route53.listResourceRecordSets({ HostedZoneId: hostedZone.Id });
+  const recordSets = await route53.listResourceRecordSets({
+    HostedZoneId: hostedZone.Id
+  });
   if (!recordSets || !recordSets.ResourceRecordSets)
     return err(`No DNS records found for domain: ${domainName}`);
   for (const recordSet of recordSets.ResourceRecordSets) {
@@ -53,10 +63,12 @@ async function deleteHostedZoneRecords(domainName) {
       await route53.changeResourceRecordSets({
         HostedZoneId: hostedZone.Id,
         ChangeBatch: {
-          Changes: [{
-            Action: "DELETE",
-            ResourceRecordSet: recordSet
-          }]
+          Changes: [
+            {
+              Action: "DELETE",
+              ResourceRecordSet: recordSet
+            }
+          ]
         }
       });
     }
@@ -66,7 +78,9 @@ async function deleteHostedZoneRecords(domainName) {
 }
 async function createHostedZone(domainName) {
   const route53 = new Route53;
-  const existingHostedZones = await route53.listHostedZonesByName({ DNSName: domainName });
+  const existingHostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName
+  });
   const existingHostedZone = existingHostedZones.HostedZones?.find((zone) => zone.Name === `${domainName}.`);
   if (existingHostedZone)
     return ok(existingHostedZone);
@@ -92,7 +106,9 @@ function writeNameserversToConfig(nameservers) {
 async function findHostedZone(domain) {
   try {
     const route53 = new Route53;
-    const { HostedZones } = await route53.listHostedZonesByName({ DNSName: domain });
+    const { HostedZones } = await route53.listHostedZonesByName({
+      DNSName: domain
+    });
     if (!HostedZones)
       return handleError(`No hosted zones found for domain ${domain}`);
     const hostedZone = HostedZones[0];
@@ -100,8 +116,8 @@ async function findHostedZone(domain) {
       return ok(hostedZone.Id);
     return ok(null);
   } catch (error) {
-    console.error(`Failed to find hosted zone for domain ${domain}:`, error);
-    return handleError(`Failed to find hosted zone for domain ${domain}:`, error);
+    console.error(error);
+    return handleError(`Failed to find hosted zone for domain ${domain}`);
   }
 }
 async function getNameservers(domainName) {
@@ -109,10 +125,13 @@ async function getNameservers(domainName) {
     return [];
   try {
     const route53Domains = new Route53Domains;
-    const domainDetail = await route53Domains.getDomainDetail({ DomainName: domainName });
+    const domainDetail = await route53Domains.getDomainDetail({
+      DomainName: domainName
+    });
     return domainDetail?.Nameservers?.map((ns) => ns.Name) || [];
   } catch (error) {
-    handleError("Error getting domain detail:", error);
+    console.error(error);
+    handleError("Error getting domain detail");
   }
 }
 async function updateNameservers(hostedZoneNameservers, domainName) {
@@ -138,12 +157,16 @@ async function hasUserDomainBeenAddedToCloud(domainName) {
   if (!domainName)
     domainName = config2.app.url;
   const route53 = new Route53;
-  const existingHostedZones = await route53.listHostedZonesByName({ DNSName: domainName });
+  const existingHostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName
+  });
   if (!existingHostedZones || !existingHostedZones.HostedZones)
     return false;
   const existingHostedZone = existingHostedZones.HostedZones.find((zone) => zone.Name === `${domainName}.`);
   if (existingHostedZone) {
-    const hostedZoneDetail = await route53.getHostedZone({ Id: existingHostedZone.Id });
+    const hostedZoneDetail = await route53.getHostedZone({
+      Id: existingHostedZone.Id
+    });
     const hostedZoneNameservers = hostedZoneDetail.DelegationSet?.NameServers || [];
     await updateNameservers(hostedZoneNameservers, domainName);
     return true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/dns",
   "type": "module",
-  "version": "0.59.11",
+  "version": "0.61.1",
   "description": "Easily manage your DNS.",
   "author": "Chris Breuer",
   "license": "MIT",
@@ -51,27 +51,27 @@
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "@aws-sdk/client-route-53": "^3.525.0",
-    "@aws-sdk/client-route-53-domains": "^3.525.0",
+    "@aws-sdk/client-route-53": "^3.577.0",
+    "@aws-sdk/client-route-53-domains": "^3.577.0",
     "@stacksjs/actions": "latest",
     "@stacksjs/error-handling": "latest",
     "@stacksjs/path": "latest",
     "@stacksjs/storage": "latest",
     "@stacksjs/whois": "latest",
-    "aws-cdk-lib": "^2.131.0"
+    "aws-cdk-lib": "^2.142.1"
   },
   "dependencies": {
-    "@aws-sdk/client-route-53": "^3.525.0",
+    "@aws-sdk/client-route-53": "^3.577.0",
     "@stacksjs/actions": "latest",
     "@stacksjs/error-handling": "latest",
     "@stacksjs/path": "latest",
     "@stacksjs/storage": "latest",
     "@stacksjs/strings": "latest",
     "@stacksjs/whois": "latest",
-    "aws-cdk-lib": "^2.131.0"
+    "aws-cdk-lib": "^2.142.1"
   },
   "devDependencies": {
     "@stacksjs/development": "latest",
-    "aws-cdk-lib": "^2.131.0"
+    "aws-cdk-lib": "^2.142.1"
   }
 }

package/src/drivers/aws.ts

@@ -1,40 +1,43 @@
 import { Route53 } from '@aws-sdk/client-route-53'
 import { Route53Domains } from '@aws-sdk/client-route-53-domains'
-import { err, handleError, ok } from '@stacksjs/error-handling'
-import { log } from '@stacksjs/logging'
 import { runAction } from '@stacksjs/actions'
-import { fs } from '@stacksjs/storage'
 import { config } from '@stacksjs/config'
-import { path as p } from '@stacksjs/path'
 import { Action } from '@stacksjs/enums'
+import { err, handleError, ok } from '@stacksjs/error-handling'
+import { log } from '@stacksjs/logging'
+import { path as p } from '@stacksjs/path'
+import { fs } from '@stacksjs/storage'
 import type { DeployOptions } from '@stacksjs/types'
 
 export async function deleteHostedZone(domainName: string) {
   const route53 = new Route53()
 
   // First, we need to get the Hosted Zone ID using the domain name
-  const hostedZones = await route53.listHostedZonesByName({ DNSName: domainName })
-  if (!hostedZones || !hostedZones.HostedZones)
-    return err((`No hosted zones found for domain: ${domainName}`))
+  const hostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName,
+  })
+  if (!hostedZones || !hostedZones.HostedZones) return err(`No hosted zones found for domain: ${domainName}`)
 
-  const hostedZone = hostedZones.HostedZones.find(zone => zone.Name === `${domainName}.`)
-  if (!hostedZone)
-    return err((`Hosted Zone not found for domain: ${domainName}`))
+  const hostedZone = hostedZones.HostedZones.find((zone) => zone.Name === `${domainName}.`)
+  if (!hostedZone) return err(`Hosted Zone not found for domain: ${domainName}`)
 
   // Delete all record sets
-  const recordSets = await route53.listResourceRecordSets({ HostedZoneId: hostedZone.Id })
-  if (!recordSets || !recordSets.ResourceRecordSets)
-    return err((`No DNS records found for domain: ${domainName}`))
+  const recordSets = await route53.listResourceRecordSets({
+    HostedZoneId: hostedZone.Id,
+  })
+  if (!recordSets || !recordSets.ResourceRecordSets) return err(`No DNS records found for domain: ${domainName}`)
 
   for (const recordSet of recordSets.ResourceRecordSets) {
     if (recordSet.Type !== 'NS' && recordSet.Type !== 'SOA') {
       await route53.changeResourceRecordSets({
         HostedZoneId: hostedZone.Id,
         ChangeBatch: {
-          Changes: [{
-            Action: 'DELETE',
-            ResourceRecordSet: recordSet,
-          }],
+          Changes: [
+            {
+              Action: 'DELETE',
+              ResourceRecordSet: recordSet,
+            },
+          ],
         },
       })
     }
@@ -54,28 +57,31 @@ export async function deleteHostedZoneRecords(domainName: string) {
   const route53 = new Route53()
 
   // First, we need to get the Hosted Zone ID using the domain name
-  const hostedZones = await route53.listHostedZonesByName({ DNSName: domainName })
-  if (!hostedZones || !hostedZones.HostedZones)
-    return err((`No hosted zones found for domain: ${domainName}`))
+  const hostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName,
+  })
+  if (!hostedZones || !hostedZones.HostedZones) return err(`No hosted zones found for domain: ${domainName}`)
 
-  const hostedZone = hostedZones.HostedZones.find(zone => zone.Name === `${domainName}.`)
-  if (!hostedZone)
-    return err((`Hosted Zone not found for domain: ${domainName}`))
+  const hostedZone = hostedZones.HostedZones.find((zone) => zone.Name === `${domainName}.`)
+  if (!hostedZone) return err(`Hosted Zone not found for domain: ${domainName}`)
 
   // Delete all record sets
-  const recordSets = await route53.listResourceRecordSets({ HostedZoneId: hostedZone.Id })
-  if (!recordSets || !recordSets.ResourceRecordSets)
-    return err((`No DNS records found for domain: ${domainName}`))
+  const recordSets = await route53.listResourceRecordSets({
+    HostedZoneId: hostedZone.Id,
+  })
+  if (!recordSets || !recordSets.ResourceRecordSets) return err(`No DNS records found for domain: ${domainName}`)
 
   for (const recordSet of recordSets.ResourceRecordSets) {
     if (recordSet.Type !== 'NS' && recordSet.Type !== 'SOA') {
       await route53.changeResourceRecordSets({
         HostedZoneId: hostedZone.Id,
         ChangeBatch: {
-          Changes: [{
-            Action: 'DELETE',
-            ResourceRecordSet: recordSet,
-          }],
+          Changes: [
+            {
+              Action: 'DELETE',
+              ResourceRecordSet: recordSet,
+            },
+          ],
         },
       })
     }
@@ -90,12 +96,13 @@ export async function createHostedZone(domainName: string) {
   const route53 = new Route53()
 
   // Check if the hosted zone already exists
-  const existingHostedZones = await route53.listHostedZonesByName({ DNSName: domainName })
-  const existingHostedZone = existingHostedZones.HostedZones?.find(zone => zone.Name === `${domainName}.`)
+  const existingHostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName,
+  })
+  const existingHostedZone = existingHostedZones.HostedZones?.find((zone) => zone.Name === `${domainName}.`)
 
   // if the hosted zone already exists, then we want to
-  if (existingHostedZone)
-    return ok(existingHostedZone)
+  if (existingHostedZone) return ok(existingHostedZone)
 
   // Create the hosted zone
   const createHostedZoneOutput = await route53.createHostedZone({
@@ -103,8 +110,7 @@ export async function createHostedZone(domainName: string) {
     CallerReference: `${Date.now()}`,
   })
 
-  if (!createHostedZoneOutput.HostedZone)
-    return err('Failed to create hosted zone')
+  if (!createHostedZoneOutput.HostedZone) return err('Failed to create hosted zone')
 
   return ok(createHostedZoneOutput)
 }
@@ -115,13 +121,12 @@ export function writeNameserversToConfig(nameservers: string[]) {
     const fileContent = fs.readFileSync(path, 'utf-8')
     const modifiedContent = fileContent.replace(
       /nameservers: \[.*?\]/s,
-      `nameservers: [${nameservers.map(ns => `'${ns}'`).join(', ')}]`,
+      `nameservers: [${nameservers.map((ns) => `'${ns}'`).join(', ')}]`,
     )
     fs.writeFileSync(path, modifiedContent, 'utf-8')
 
     log.info('Nameservers have been set.')
-  }
-  catch (err) {
+  } catch (err) {
     console.error('Error updating nameservers:', err)
   }
 }
@@ -129,48 +134,51 @@ export function writeNameserversToConfig(nameservers: string[]) {
 export async function findHostedZone(domain: string) {
   try {
     const route53 = new Route53()
-    const { HostedZones } = await route53.listHostedZonesByName({ DNSName: domain })
+    const { HostedZones } = await route53.listHostedZonesByName({
+      DNSName: domain,
+    })
 
-    if (!HostedZones)
-      return handleError(`No hosted zones found for domain ${domain}`)
+    if (!HostedZones) return handleError(`No hosted zones found for domain ${domain}`)
 
     // The API returns hosted zones sorted by name in ASCII order,
     // so the desired hosted zone (if it exists) should be the first one in the list
     const hostedZone = HostedZones[0]
 
-    if (hostedZone && hostedZone.Name === `${domain}.`)
-      return ok(hostedZone.Id)
+    if (hostedZone && hostedZone.Name === `${domain}.`) return ok(hostedZone.Id)
 
     return ok(null)
-  }
-  catch (error) {
-    console.error(`Failed to find hosted zone for domain ${domain}:`, error)
-    return handleError(`Failed to find hosted zone for domain ${domain}:`, error as Error)
+  } catch (error) {
+    console.error(error)
+    return handleError(`Failed to find hosted zone for domain ${domain}`)
   }
 }
 
 export async function getNameservers(domainName?: string) {
-  if (!domainName)
-    return []
+  if (!domainName) return []
 
   try {
     const route53Domains = new Route53Domains()
-    const domainDetail = await route53Domains.getDomainDetail({ DomainName: domainName })
+    const domainDetail = await route53Domains.getDomainDetail({
+      DomainName: domainName,
+    })
 
-    return domainDetail?.Nameservers?.map(ns => ns.Name as string) || []
-  }
-  catch (error) {
-    handleError('Error getting domain detail:', error as Error)
+    return domainDetail?.Nameservers?.map((ns) => ns.Name as string) || []
+  } catch (error) {
+    console.error(error)
+    handleError('Error getting domain detail')
   }
 }
 
 export async function updateNameservers(hostedZoneNameservers: string[], domainName?: string) {
-  if (!domainName)
-    domainName = config.app.url
+  if (!domainName) domainName = config.app.url
 
   const domainNameservers = await getNameservers(domainName)
 
-  if (domainNameservers && hostedZoneNameservers && JSON.stringify(domainNameservers.sort()) !== JSON.stringify(hostedZoneNameservers.sort())) {
+  if (
+    domainNameservers &&
+    hostedZoneNameservers &&
+    JSON.stringify(domainNameservers.sort()) !== JSON.stringify(hostedZoneNameservers.sort())
+  ) {
     log.info('Updating your domain nameservers to match the ones in your hosted zone...')
     log.debug('Hosted zone nameservers:', hostedZoneNameservers)
     log.debug('Domain nameservers:', domainNameservers)
@@ -178,7 +186,7 @@ export async function updateNameservers(hostedZoneNameservers: string[], domainN
 
     await route53Domains.updateDomainNameservers({
       DomainName: domainName,
-      Nameservers: hostedZoneNameservers.map(ns => ({ Name: ns })),
+      Nameservers: hostedZoneNameservers.map((ns) => ({ Name: ns })),
     })
 
     writeNameserversToConfig(hostedZoneNameservers)
@@ -192,21 +200,23 @@ export async function updateNameservers(hostedZoneNameservers: string[], domainN
 
 // please note, this function also updates the user's nameservers if they are out of date
 export async function hasUserDomainBeenAddedToCloud(domainName?: string) {
-  if (!domainName)
-    domainName = config.app.url
+  if (!domainName) domainName = config.app.url
 
   const route53 = new Route53()
 
   // check if the hosted zone already exists
-  const existingHostedZones = await route53.listHostedZonesByName({ DNSName: domainName })
+  const existingHostedZones = await route53.listHostedZonesByName({
+    DNSName: domainName,
+  })
 
-  if (!existingHostedZones || !existingHostedZones.HostedZones)
-    return false
+  if (!existingHostedZones || !existingHostedZones.HostedZones) return false
 
-  const existingHostedZone = existingHostedZones.HostedZones.find(zone => zone.Name === `${domainName}.`)
+  const existingHostedZone = existingHostedZones.HostedZones.find((zone) => zone.Name === `${domainName}.`)
 
   if (existingHostedZone) {
-    const hostedZoneDetail = await route53.getHostedZone({ Id: existingHostedZone.Id })
+    const hostedZoneDetail = await route53.getHostedZone({
+      Id: existingHostedZone.Id,
+    })
     const hostedZoneNameservers = hostedZoneDetail.DelegationSet?.NameServers || []
 
     await updateNameservers(hostedZoneNameservers, domainName)

package/src/index.ts

@@ -10,7 +10,6 @@
 //     if (!app.url)
 //       throw new Error('./config app.url is not defined')
 
-//     // eslint-disable-next-line no-new
 //     new route53.PublicHostedZone(this, 'HostedZone', {
 //       zoneName: app.url,
 //     })

package/dist/drivers/aws.d.ts

@@ -1,10 +0,0 @@
-import type { DeployOptions } from '@stacksjs/types';
-export declare function deleteHostedZone(domainName: string): Promise<import("neverthrow").Err<never, string> | import("neverthrow").Ok<string, never>>;
-export declare function deleteHostedZoneRecords(domainName: string): Promise<import("neverthrow").Err<never, string> | import("neverthrow").Ok<string, never>>;
-export declare function createHostedZone(domainName: string): Promise<import("neverthrow").Err<never, string> | import("neverthrow").Ok<import("@aws-sdk/client-route-53").HostedZone, never> | import("neverthrow").Ok<import("@aws-sdk/client-route-53").CreateHostedZoneCommandOutput, never>>;
-export declare function writeNameserversToConfig(nameservers: string[]): void;
-export declare function findHostedZone(domain: string): Promise<Error | import("neverthrow").Ok<string | undefined, never> | import("neverthrow").Ok<null, never>>;
-export declare function getNameservers(domainName?: string): Promise<string[] | undefined>;
-export declare function updateNameservers(hostedZoneNameservers: string[], domainName?: string): Promise<true | undefined>;
-export declare function hasUserDomainBeenAddedToCloud(domainName?: string): Promise<boolean>;
-export declare function addDomain(options: DeployOptions): Promise<any>;

package/dist/index.d.ts

@@ -1 +0,0 @@
-export * from './drivers/aws';