t44 0.4.0-rc.3

package/caps/providers/dynadot.com/api-domains.test.ts

@@ -0,0 +1,224 @@
+#!/usr/bin/env bun test
+
+export const testConfig = {
+    group: 'vendor',
+    runOnAll: false,
+}
+
+import * as bunTest from 'bun:test'
+import { run } from 't44/workspace-rt'
+
+const {
+    test: { describe, it, expect },
+    domains
+} = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceTest',
+                    options: {
+                        '#': {
+                            bunTest,
+                            env: {
+                                DYNADOT_API_KEY: { factReference: 't44/structs/providers/dynadot.com/WorkspaceConnectionConfig:apiKey' },
+                                DYNADOT_API_SECRET: { factReference: 't44/structs/providers/dynadot.com/WorkspaceConnectionConfig:apiSecret' },
+                                DYNADOT_API_KEY_TRANSACTION_SECRET: { factReference: 't44/structs/providers/dynadot.com/WorkspaceConnectionConfig:apiKeyTransactionSecret' }
+                            }
+                        }
+                    }
+                },
+                domains: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-domains'
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: 't44/caps/providers/dynadot.com/api-domains.test'
+    })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, {
+    importMeta: import.meta
+})
+
+describe('Dynadot Domain API', function () {
+
+    let domainName: string
+
+    it('should return list of domains', async function () {
+
+        const result = await domains.list()
+
+        expect(result).toBeObject()
+        expect(result.code).toBe(200)
+        expect(result.data).toBeObject()
+        expect(result.data.domain_info).toBeArray()
+        expect(result.data.domain_info.length).toBeGreaterThan(0)
+
+        domainName = result.data.domain_info[0].domain_name
+    })
+
+    it('should return domain info for a specific domain', async function () {
+
+        const result = await domains.getInfo({ name: domainName })
+
+        expect(result).toBeObject()
+        expect(result.code).toBe(200)
+        expect(result.data).toBeObject()
+        expect(result.data.domain_info).toBeArray()
+        expect(result.data.domain_info[0].domain_name).toBe(domainName)
+    })
+
+    it('should return DNS records for a specific domain', async function () {
+
+        const result = await domains.getDns({ name: domainName })
+
+        expect(result).toBeObject()
+        expect(result.code).toBe(200)
+        expect(result.data).toBeObject()
+        expect(result.data.domain_info).toBeArray()
+        expect(result.data.domain_info[0].glue_info).toBeObject()
+    })
+
+    it('should return nameservers for a specific domain', async function () {
+
+        const result = await domains.getNameservers({ name: domainName })
+
+        expect(result).toBeObject()
+        expect(result.code).toBe(200)
+    })
+
+    it('should set an ANAME main domain record via v2 API', async function () {
+
+        // v2 API supports ANAME record type (v1 did not)
+        const setResult = await domains.setDns({
+            name: domainName,
+            records: [],
+            mainDomains: [{ recordType: 'aname', value: 'example.com' }],
+        })
+        expect(setResult).toBeObject()
+        expect(setResult.code).toBe(200)
+
+        // Verify ANAME was set
+        const verifyDns = await domains.getDns({ name: domainName })
+        expect(verifyDns.code).toBe(200)
+        const nsSettings = verifyDns.data.domain_info[0].glue_info?.name_server_settings
+        const mainRecords = nsSettings?.main_domains || []
+        const anameRecord = mainRecords.find((r: any) => r.record_type === 'aname')
+        expect(anameRecord).toBeDefined()
+        expect(anameRecord.value).toBe('example.com')
+
+        // Clean up: restore with a simple A record
+        await domains.setDns({
+            name: domainName,
+            records: [],
+            mainDomains: [{ recordType: 'a', value: '127.0.0.1' }]
+        })
+    })
+
+    it('should preserve existing records when using addToCurrent', async function () {
+
+        // First set a baseline record
+        const baseResult = await domains.setDns({
+            name: domainName,
+            records: [{ subdomain: 't44-test-preserve-base', record_type: 'cname', value: 'base.example.com' }],
+            mainDomains: [{ recordType: 'a', value: '127.0.0.1' }]
+        })
+        expect(baseResult.code).toBe(200)
+
+        // Add another record using addToCurrent — should preserve the base record
+        const addResult = await domains.setDns({
+            name: domainName,
+            records: [{ subdomain: 't44-test-preserve-add', record_type: 'cname', value: 'add.example.com' }],
+            mainDomains: [],
+            addToCurrent: true
+        })
+        expect(addResult.code).toBe(200)
+
+        // Verify both records exist
+        const verifyDns = await domains.getDns({ name: domainName })
+        const nsSettings = verifyDns.data.domain_info[0].glue_info?.name_server_settings
+        const subDomains = nsSettings?.sub_domains || []
+        const baseRecord = subDomains.find((r: any) => r.sub_host === 't44-test-preserve-base')
+        const addRecord = subDomains.find((r: any) => r.sub_host === 't44-test-preserve-add')
+        expect(baseRecord).toBeDefined()
+        expect(addRecord).toBeDefined()
+
+        // Clean up
+        await domains.setDns({
+            name: domainName,
+            records: [],
+            mainDomains: [{ recordType: 'a', value: '127.0.0.1' }]
+        })
+    })
+
+    it('should set DNS records, verify, and restore original', async function () {
+
+        const originalDns = await domains.getDns({ name: domainName })
+        expect(originalDns).toBeObject()
+        expect(originalDns.code).toBe(200)
+
+        const nsSettings = originalDns.data.domain_info[0].glue_info?.name_server_settings
+        const allOriginalRecords = nsSettings?.sub_domains || []
+        // Filter out any leftover test records to avoid duplicate subhost error
+        const originalRecords = allOriginalRecords.filter((r: any) => r.sub_host !== 't44-test-api-domains')
+
+        const testCnameRecord = {
+            record_type: 'cname',
+            subdomain: 't44-test-api-domains',
+            value: 'example.com'
+        }
+
+        const updatedRecords = [...originalRecords.map((r: any) => ({
+            record_type: r.record_type.toLowerCase(),
+            subdomain: r.sub_host,
+            value: r.value
+        })), testCnameRecord]
+
+        const setResult = await domains.setDns({
+            name: domainName,
+            records: updatedRecords
+        })
+        expect(setResult).toBeObject()
+        expect(setResult.code).toBe(200)
+
+        const verifyDns = await domains.getDns({ name: domainName })
+        expect(verifyDns).toBeObject()
+        expect(verifyDns.code).toBe(200)
+        const verifyNs = verifyDns.data.domain_info[0].glue_info?.name_server_settings
+        const verifyRecords = verifyNs?.sub_domains || []
+        expect(verifyRecords.length).toBe(originalRecords.length + 1)
+
+        const foundNewRecord = verifyRecords.find((r: any) => r.sub_host === 't44-test-api-domains')
+        expect(foundNewRecord).toBeDefined()
+        expect(foundNewRecord.record_type).toBe('cname')
+        expect(foundNewRecord.value).toBe('example.com')
+
+        // Restore original DNS by overwriting with original records
+        // If original had records, restore them; otherwise restore with just the original set
+        const restoreRecords = originalRecords.length > 0
+            ? originalRecords.map((r: any) => ({
+                record_type: r.record_type.toLowerCase(),
+                subdomain: r.sub_host,
+                value: r.value
+            }))
+            : [] // empty sub_list will clear subdomain records when dns_main_list is provided
+
+        const restoreResult = await domains.setDns({
+            name: domainName,
+            records: restoreRecords,
+            // Provide a main domain record to satisfy the "at least one DNS record" requirement
+            mainDomains: [{ recordType: 'a', value: '127.0.0.1' }]
+        })
+        expect(restoreResult).toBeObject()
+        expect(restoreResult.code).toBe(200)
+    })
+
+})

package/caps/providers/dynadot.com/api-domains.ts

@@ -0,0 +1,169 @@
+
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+
+    // Dynadot REST API v2
+    // Docs: https://www.dynadot.com/domain/api-document
+    // All operations use v2 (snake_case response: domain_info, glue_info, etc.)
+    // v2 supports ANAME record type
+    // DNS records: POST domains/{name}/records (body: { dns_main_list, sub_list, ttl, add_dns_to_current_setting })
+    // DNS read: embedded in domain info via glue_info.name_server_settings
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/providers/dynadot.com/DomainFact': {
+                as: '$DomainFact'
+            },
+            '#': {
+
+                api: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-restful-v2'
+                },
+
+                list: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any) {
+                        const result = await this.api.call({
+                            method: 'GET',
+                            path: 'domains',
+                            operation: 'list'
+                        });
+
+                        await this.$DomainFact.set('list', result);
+
+                        return result;
+                    }
+                },
+
+                getInfo: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string }) {
+                        const result = await this.api.call({
+                            method: 'GET',
+                            path: `domains/${options.name}`,
+                            operation: 'info'
+                        });
+
+                        await this.$DomainFact.set(options.name, result);
+
+                        return result;
+                    }
+                },
+
+                getDns: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string }) {
+                        // DNS info is embedded in domain info via glueInfo.name_server_settings
+                        const result = await this.api.call({
+                            method: 'GET',
+                            path: `domains/${options.name}`,
+                            operation: 'getDns'
+                        });
+
+                        await this.$DomainFact.set(options.name, result);
+
+                        return result;
+                    }
+                },
+
+                getNameservers: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: { name: string }) {
+                        const result = await this.api.call({
+                            method: 'GET',
+                            path: `domains/${options.name}/nameservers`,
+                            operation: 'getNameservers'
+                        });
+
+                        await this.$DomainFact.set(options.name, result);
+
+                        return result;
+                    }
+                },
+
+                setDns: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        name: string;
+                        records: any[];
+                        mainDomain?: { recordType: string; value: string; value2?: string };
+                        mainDomains?: Array<{ recordType: string; value: string; value2?: string }>;
+                        addToCurrent?: boolean;
+                    }) {
+                        const mainDomains = options.mainDomains || (options.mainDomain ? [options.mainDomain] : []);
+
+                        // v1 REST API body format per docs:
+                        // { dns_main_list, sub_list, ttl, add_dns_to_current_setting }
+                        const body: Record<string, any> = {}
+
+                        if (options.addToCurrent) {
+                            body.add_dns_to_current_setting = true
+                        }
+
+                        // dns_main_list is required by the v2 API (at least one entry)
+                        if (mainDomains.length > 0) {
+                            body.dns_main_list = mainDomains.map(r => {
+                                const record: any = {
+                                    record_type: r.recordType,
+                                    record_value1: r.value,
+                                }
+                                if (r.value2 !== undefined) {
+                                    record.record_value2 = r.value2
+                                }
+                                return record
+                            })
+                        } else {
+                            // Fetch current main records to preserve them
+                            const current = await this.api.call({
+                                method: 'GET',
+                                path: `domains/${options.name}`,
+                                operation: 'getDns'
+                            })
+                            const ns = current?.data?.domain_info?.[0]?.glue_info?.name_server_settings || {}
+                            const existingMain = ns.main_domains || []
+                            body.dns_main_list = existingMain.length > 0
+                                ? existingMain.map((r: any) => ({
+                                    record_type: r.record_type,
+                                    record_value1: r.value || r.record_value1,
+                                    ...(r.record_value2 ? { record_value2: r.record_value2 } : {}),
+                                }))
+                                : [{ record_type: 'a', record_value1: '127.0.0.1' }]
+                        }
+
+                        if (options.records.length > 0) {
+                            body.sub_list = options.records.map(r => ({
+                                sub_host: r.subdomain,
+                                record_type: r.record_type,
+                                record_value1: r.value,
+                            }))
+                        }
+
+                        // POST /restful/v2/domains/{domain_name}/records
+                        return await this.api.call({
+                            method: 'POST',
+                            path: `domains/${options.name}/records`,
+                            body,
+                            operation: 'setDns'
+                        })
+                    }
+                }
+
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/dynadot.com/api-domains'
+

package/caps/providers/dynadot.com/api-restful-v1.test.ts

@@ -0,0 +1,190 @@
+#!/usr/bin/env bun test
+
+export const testConfig = {
+    group: 'vendor',
+    runOnAll: false,
+}
+
+import * as bunTest from 'bun:test'
+import { run } from 't44/workspace-rt'
+
+const {
+    test: { describe, it, expect },
+    api
+} = await run(async ({ encapsulate, CapsulePropertyTypes, makeImportStack }: any) => {
+    const spine = await encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                test: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: 't44/caps/WorkspaceTest',
+                    options: {
+                        '#': {
+                            bunTest,
+                            env: {
+                                DYNADOT_API_KEY: { factReference: 't44/structs/providers/dynadot.com/WorkspaceConnectionConfig:apiKey' },
+                                DYNADOT_API_SECRET: { factReference: 't44/structs/providers/dynadot.com/WorkspaceConnectionConfig:apiSecret' },
+                            }
+                        }
+                    }
+                },
+                api: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-restful-v1'
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: 't44/caps/providers/dynadot.com/api-restful-v1.test'
+    })
+    return { spine }
+}, async ({ spine, apis }: any) => {
+    return apis[spine.capsuleSourceLineRef]
+}, {
+    importMeta: import.meta
+})
+
+describe('Dynadot REST API v1', function () {
+
+    let domainName: string
+
+    it('should list domains', async function () {
+
+        const result = await api.call({
+            method: 'GET',
+            path: 'domains',
+            operation: 'list'
+        })
+
+        expect(result).toBeObject()
+        expect(result.code).toBe(200)
+        expect(result.data).toBeObject()
+        expect(result.data.domainInfo).toBeArray()
+        expect(result.data.domainInfo.length).toBeGreaterThan(0)
+
+        domainName = result.data.domainInfo[0].domainName
+    })
+
+    it('should get domain info for first domain', async function () {
+
+        const result = await api.call({
+            method: 'GET',
+            path: `domains/${domainName}`,
+            operation: 'info'
+        })
+
+        expect(result).toBeObject()
+        expect(result.code).toBe(200)
+        expect(result.data).toBeObject()
+        expect(result.data.domainInfo).toBeArray()
+        expect(result.data.domainInfo[0].domainName).toBe(domainName)
+    })
+
+    it('should set a TXT test record, verify, remove, and verify removal', async function () {
+
+        // 1. Get current DNS to snapshot existing records
+        const beforeDns = await api.call({
+            method: 'GET',
+            path: `domains/${domainName}`,
+            operation: 'getDns'
+        })
+        expect(beforeDns.code).toBe(200)
+        const nsBefore = beforeDns.data.domainInfo[0].glueInfo?.name_server_settings || {}
+        const existingMainRecords = nsBefore.main_records || nsBefore.dns_main_list || []
+        const existingSubs = nsBefore.sub_domains || []
+
+        // 2. Add a TXT test record using add_dns_to_current_setting to preserve all existing records
+        const setResult = await api.call({
+            method: 'POST',
+            path: `domains/${domainName}/records`,
+            body: {
+                add_dns_to_current_setting: true,
+                dns_main_list: [],
+                sub_list: [{
+                    sub_host: 't44-v1-api-test',
+                    record_type: 'txt',
+                    record_value1: 'v1-test-value'
+                }]
+            },
+            operation: 'setDns'
+        })
+        expect(setResult).toBeObject()
+        expect(setResult.code).toBe(200)
+
+        // 3. Get DNS again — verify TXT record was added and existing records preserved
+        const afterSet = await api.call({
+            method: 'GET',
+            path: `domains/${domainName}`,
+            operation: 'getDns'
+        })
+        expect(afterSet.code).toBe(200)
+        const nsAfterSet = afterSet.data.domainInfo[0].glueInfo?.name_server_settings || {}
+        const subsAfterSet = nsAfterSet.sub_domains || []
+
+        const txtRecord = subsAfterSet.find((r: any) => r.sub_host === 't44-v1-api-test')
+        expect(txtRecord).toBeDefined()
+        expect(txtRecord.record_type).toBe('txt')
+        expect(txtRecord.value).toBe('v1-test-value')
+
+        // Verify existing subdomain records are still present
+        for (const orig of existingSubs) {
+            const found = subsAfterSet.find((r: any) => r.sub_host === orig.sub_host && r.record_type === orig.record_type)
+            expect(found).toBeDefined()
+        }
+
+        // 4. Remove the TXT record by re-setting all records WITHOUT the test record
+        const subsWithoutTest = subsAfterSet
+            .filter((r: any) => r.sub_host !== 't44-v1-api-test')
+            .map((r: any) => ({
+                sub_host: r.sub_host,
+                record_type: r.record_type,
+                record_value1: r.value,
+            }))
+
+        const mainRecordsForRestore = (nsAfterSet.main_records || nsAfterSet.dns_main_list || []).map((r: any) => ({
+            record_type: r.record_type,
+            record_value1: r.value || r.record_value1,
+            ...(r.record_value2 ? { record_value2: r.record_value2 } : {}),
+        }))
+
+        // Need at least one dns_main_list entry
+        const dnsMainList = mainRecordsForRestore.length > 0
+            ? mainRecordsForRestore
+            : [{ record_type: 'a', record_value1: '127.0.0.1' }]
+
+        const removeResult = await api.call({
+            method: 'POST',
+            path: `domains/${domainName}/records`,
+            body: {
+                dns_main_list: dnsMainList,
+                sub_list: subsWithoutTest,
+            },
+            operation: 'setDns'
+        })
+        expect(removeResult).toBeObject()
+        expect(removeResult.code).toBe(200)
+
+        // 5. Get DNS again — verify TXT record is gone and original records restored
+        const afterRemove = await api.call({
+            method: 'GET',
+            path: `domains/${domainName}`,
+            operation: 'getDns'
+        })
+        expect(afterRemove.code).toBe(200)
+        const nsAfterRemove = afterRemove.data.domainInfo[0].glueInfo?.name_server_settings || {}
+        const subsAfterRemove = nsAfterRemove.sub_domains || []
+
+        const removedRecord = subsAfterRemove.find((r: any) => r.sub_host === 't44-v1-api-test')
+        expect(removedRecord).toBeUndefined()
+
+        // Verify original subdomain records are still present
+        for (const orig of existingSubs) {
+            const found = subsAfterRemove.find((r: any) => r.sub_host === orig.sub_host && r.record_type === orig.record_type)
+            expect(found).toBeDefined()
+        }
+    })
+
+})

package/caps/providers/dynadot.com/api-restful-v1.ts

@@ -0,0 +1,94 @@
+
+import axios from 'axios';
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    // Dynadot REST API v1
+    // Docs: https://www.dynadot.com/domain/api-document
+    // Reference impl: https://github.com/level23/dynadot-api
+    // URL format: https://api.dynadot.com/restful/v1/{resource}/{resource_identify}/{action}
+    // Auth: Bearer apiKey, HMAC-SHA256 signed with apiSecret
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/providers/dynadot.com/WorkspaceConnectionConfig': {
+                as: '$ConnectionConfig'
+            },
+            '#': {
+
+                call: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+                        path: string;
+                        query?: Record<string, string>;
+                        body?: any;
+                        operation?: string;
+                    }) {
+                        const { createHmac, randomUUID } = await import('crypto')
+                        const apiKey = await this.$ConnectionConfig.getConfigValue('apiKey')
+                        const apiSecret = await this.$ConnectionConfig.getConfigValue('apiSecret')
+
+                        const baseUrl = 'https://api.dynadot.com/restful/v1/'
+                        const relativePath = options.path.replace(/^\//, '')
+                        const requestId = randomUUID()
+
+                        // Build request
+                        const axiosOpts: any = {
+                            method: options.method,
+                            url: `${baseUrl}${relativePath}`,
+                            headers: {
+                                'Authorization': `Bearer ${apiKey}`,
+                                'X-Request-Id': requestId,
+                                'Accept': 'application/json',
+                                'Content-Type': 'application/json',
+                            },
+                            validateStatus: () => true,
+                        }
+
+                        // For GET: params as query string, empty payload
+                        // For POST/PUT: JSON body as payload
+                        // Send pre-serialized string to ensure signature matches body exactly
+                        let payloadJson = ''
+                        if (options.method === 'GET' && options.query) {
+                            axiosOpts.params = options.query
+                        } else if (options.body) {
+                            payloadJson = JSON.stringify(options.body)
+                            axiosOpts.data = payloadJson
+                        }
+
+                        // HMAC-SHA256 signature: sign with apiSecret, relative path
+                        const stringToSign = `${apiKey}\n${relativePath}\n${requestId}\n${payloadJson}`
+                        const signature = createHmac('sha256', apiSecret).update(stringToSign).digest('hex')
+                        axiosOpts.headers['X-Signature'] = signature
+
+                        const response = await axios(axiosOpts)
+
+                        if (response.status >= 400 || (response.data?.code && response.data.code >= 400)) {
+                            const errorData = response.data
+                            const operationName = options.operation || options.path
+                            const desc = errorData?.error?.description || errorData?.message || JSON.stringify(errorData)
+                            throw new Error(`Dynadot API ${operationName} failed: ${response.status} - ${desc}`)
+                        }
+
+                        return response.data
+                    }
+                }
+
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/dynadot.com/api-restful-v1'
+