@stacksjs/dns 0.64.6 → 0.65.0

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@stacksjs/dns",
   "type": "module",
-  "version": "0.64.6",
+  "version": "0.65.0",
   "description": "Easily manage your DNS.",
   "author": "Chris Breuer",
+  "contributors": ["Chris Breuer <chris@stacksjs.org>"],
   "license": "MIT",
   "funding": "https://github.com/sponsors/chrisbbreuer",
   "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/dns#readme",
@@ -37,31 +38,24 @@
       "import": "./dist/*"
     }
   },
-  "contributors": [
-    "Chris Breuer <chris@stacksjs.org>"
-  ],
-  "files": [
-    "README.md",
-    "dist",
-    "src"
-  ],
+  "files": ["README.md", "dist", "src"],
   "scripts": {
-    "build": "bun --bun build.ts",
-    "typecheck": "bun --bun tsc --noEmit",
+    "build": "bun build.ts",
+    "typecheck": "bun tsc --noEmit",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@aws-sdk/client-route-53": "^3.637.0",
-    "@stacksjs/actions": "latest",
-    "@stacksjs/error-handling": "latest",
-    "@stacksjs/path": "latest",
-    "@stacksjs/storage": "latest",
-    "@stacksjs/strings": "latest",
-    "@stacksjs/whois": "latest",
-    "aws-cdk-lib": "^2.154.1"
+    "@aws-sdk/client-route-53": "^3.668.0",
+    "@stacksjs/actions": "0.64.6",
+    "@stacksjs/error-handling": "0.64.6",
+    "@stacksjs/path": "0.64.6",
+    "@stacksjs/storage": "0.64.6",
+    "@stacksjs/strings": "0.64.6",
+    "@stacksjs/whois": "0.64.6",
+    "aws-cdk-lib": "^2.161.1"
   },
   "devDependencies": {
-    "@stacksjs/development": "latest",
-    "aws-cdk-lib": "^2.154.1"
+    "@stacksjs/development": "0.64.6",
+    "aws-cdk-lib": "^2.161.1"
   }
 }

package/src/drivers/aws.ts

@@ -1,3 +1,6 @@
+import type { CreateHostedZoneCommandOutput, HostedZone } from '@aws-sdk/client-route-53'
+import type { Result } from '@stacksjs/error-handling'
+import type { CommandError, DeployOptions, Subprocess } from '@stacksjs/types'
 import { Route53 } from '@aws-sdk/client-route-53'
 import { Route53Domains } from '@aws-sdk/client-route-53-domains'
 import { runAction } from '@stacksjs/actions'
@@ -7,25 +10,27 @@ 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) {
+export async function deleteHostedZone(domainName: string): Promise<Result<string, Error>> {
   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}`)
+  if (!hostedZones || !hostedZones.HostedZones)
+    return err(handleError(`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(handleError(`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}`)
+  if (!recordSets || !recordSets.ResourceRecordSets)
+    return err(handleError(`No DNS records found for domain: ${domainName}`))
 
   for (const recordSet of recordSets.ResourceRecordSets) {
     if (recordSet.Type !== 'NS' && recordSet.Type !== 'SOA') {
@@ -53,23 +58,26 @@ export async function deleteHostedZone(domainName: string) {
 
 // sometimes it’s useful to delete all records but keep the hosted zone
 // for example, if you want to keep the nameservers
-export async function deleteHostedZoneRecords(domainName: string) {
+export async function deleteHostedZoneRecords(domainName: string): Promise<Result<string, Error>> {
   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}`)
+  if (!hostedZones || !hostedZones.HostedZones)
+    return err(handleError(`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(handleError(`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}`)
+  if (!recordSets || !recordSets.ResourceRecordSets)
+    return err(handleError(`No DNS records found for domain: ${domainName}`))
 
   for (const recordSet of recordSets.ResourceRecordSets) {
     if (recordSet.Type !== 'NS' && recordSet.Type !== 'SOA') {
@@ -92,17 +100,20 @@ export async function deleteHostedZoneRecords(domainName: string) {
   return ok('success')
 }
 
-export async function createHostedZone(domainName: string) {
+export async function createHostedZone(
+  domainName: string,
+): Promise<Result<HostedZone | CreateHostedZoneCommandOutput | string | null, Error>> {
   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 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({
@@ -110,51 +121,57 @@ export async function createHostedZone(domainName: string) {
     CallerReference: `${Date.now()}`,
   })
 
-  if (!createHostedZoneOutput.HostedZone) return err('Failed to create hosted zone')
+  if (!createHostedZoneOutput.HostedZone)
+    return err(handleError('Failed to create hosted zone'))
 
   return ok(createHostedZoneOutput)
 }
 
-export function writeNameserversToConfig(nameservers: string[]) {
+export function writeNameserversToConfig(nameservers: string[]): void {
   try {
     const path = p.projectConfigPath('dns.ts')
     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)
   }
 }
 
-export async function findHostedZone(domain: string) {
+export async function findHostedZone(domain: string): Promise<Result<string | null | undefined, Error>> {
   try {
     const route53 = new Route53()
     const { HostedZones } = await route53.listHostedZonesByName({
       DNSName: domain,
     })
 
-    if (!HostedZones) return handleError(`No hosted zones found for domain ${domain}`)
+    if (!HostedZones)
+      return err(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(error)
-    return handleError(`Failed to find hosted zone for domain ${domain}`)
+  }
+  catch (error) {
+    return err(handleError(`Failed to find hosted zone for domain ${domain}`, error))
   }
 }
 
-export async function getNameservers(domainName?: string) {
-  if (!domainName) return []
+export async function getNameservers(domainName?: string): Promise<string[] | undefined> {
+  log.debug('Getting nameservers for domain:', domainName)
+  if (!domainName)
+    return []
 
   try {
     const route53Domains = new Route53Domains()
@@ -162,22 +179,25 @@ export async function getNameservers(domainName?: string) {
       DomainName: domainName,
     })
 
-    return domainDetail?.Nameservers?.map((ns) => ns.Name as string) || []
-  } catch (error) {
-    console.error(error)
-    handleError('Error getting domain detail')
+    return domainDetail?.Nameservers?.map(ns => ns.Name as string) || []
+  }
+  catch (error) {
+    handleError('Error getting domain detail', error)
   }
 }
 
-export async function updateNameservers(hostedZoneNameservers: string[], domainName?: string) {
-  if (!domainName) domainName = config.app.url
+export async function updateNameservers(
+  hostedZoneNameservers: string[],
+  domainName?: string,
+): Promise<boolean | undefined> {
+  if (!domainName)
+    domainName = config.app.url
 
   const domainNameservers = await getNameservers(domainName)
-
   if (
-    domainNameservers &&
-    hostedZoneNameservers &&
-    JSON.stringify(domainNameservers.sort()) !== JSON.stringify(hostedZoneNameservers.sort())
+    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)
@@ -186,7 +206,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)
@@ -199,21 +219,27 @@ 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
-
-  const route53 = new Route53()
+export async function hasUserDomainBeenAddedToCloud(domainName?: string): Promise<boolean> {
+  log.debug('Checking if domain has been added to cloud...')
+  if (!domainName)
+    domainName = config.app.url
+  log.debug('domainName:', domainName)
 
   // check if the hosted zone already exists
+  const route53 = new Route53()
   const existingHostedZones = await route53.listHostedZonesByName({
     DNSName: domainName,
   })
+  log.debug('Existing hosted zones:', existingHostedZones)
 
-  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) {
+    log.debug('Hosted zone found:', existingHostedZone)
+
     const hostedZoneDetail = await route53.getHostedZone({
       Id: existingHostedZone.Id,
     })
@@ -229,6 +255,6 @@ export async function hasUserDomainBeenAddedToCloud(domainName?: string) {
   return false
 }
 
-export async function addDomain(options: DeployOptions) {
+export async function addDomain(options: DeployOptions): Promise<Result<Subprocess, CommandError>> {
   return await runAction(Action.DomainsAdd, options)
 }