t44 0.4.0-rc.3

package/caps/providers/bunny.net/api-storage.ts

@@ -0,0 +1,248 @@
+
+import uploadToBunny from 'upload-to-bunny'
+
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+
+    // https://docs.bunny.net/api-reference/core/storage-zone/
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/providers/bunny.net/StorageZoneFact': {
+                as: '$StorageZoneFact'
+            },
+            '#t44/structs/providers/bunny.net/StorageZoneListFact': {
+                as: '$StorageZoneListFact'
+            },
+            '#': {
+
+                api: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api'
+                },
+
+                listZones: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options?: { page?: number; perPage?: number; search?: string }) {
+                        const params: Record<string, string | number> = {};
+                        if (options?.page !== undefined) {
+                            params.page = options.page;
+                        }
+                        if (options?.perPage !== undefined) {
+                            params.perPage = options.perPage;
+                        }
+                        if (options?.search) {
+                            params.search = options.search;
+                        }
+
+                        const result = await this.api.call({
+                            method: 'GET',
+                            url: 'https://api.bunny.net/storagezone',
+                            params,
+                            operation: 'listZones'
+                        });
+
+                        await this.$StorageZoneListFact.set('list', result);
+
+                        return result;
+                    }
+                },
+
+                createZone: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        name: string;
+                        region: string;
+                        replicationRegions?: string[];
+                        zoneTier?: 'Standard' | 'Premium';
+                        storageZoneType?: 'NotSupported' | 'Standard' | 'Premium';
+                    }) {
+                        return await this.api.call({
+                            method: 'POST',
+                            url: 'https://api.bunny.net/storagezone',
+                            data: {
+                                Name: options.name,
+                                Region: options.region,
+                                ReplicationRegions: options.replicationRegions || [],
+                                ZoneTier: options.zoneTier || 'Standard',
+                                StorageZoneType: options.storageZoneType || 'NotSupported'
+                            },
+                            operation: 'createZone'
+                        });
+                    }
+                },
+
+                ensureZone: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        name: string;
+                        region: string;
+                        replicationRegions?: string[];
+                        zoneTier?: 'Standard' | 'Premium';
+                        storageZoneType?: 'NotSupported' | 'Standard' | 'Premium';
+                    }) {
+                        const zones = await this.listZones({ search: options.name });
+                        const existingZone = zones.find((zone: any) => zone.Name === options.name);
+
+                        if (existingZone) {
+                            return await this.getZone(existingZone.Id);
+                        }
+
+                        return await this.createZone(options);
+                    }
+                },
+
+                getZone: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, id: number) {
+                        const storageZone = await this.api.call({
+                            method: 'GET',
+                            url: `https://api.bunny.net/storagezone/${id}`,
+                            operation: 'getZone'
+                        });
+
+                        if (storageZone && storageZone.Name) {
+                            await this.$StorageZoneFact.set(storageZone.Name, storageZone);
+                        }
+
+                        return storageZone;
+                    }
+                },
+
+                deleteZone: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, id: number, deletePullZones: boolean = true) {
+                        const params: Record<string, string | boolean> = {};
+                        if (!deletePullZones) {
+                            params.deletePullZones = false;
+                        }
+
+                        return await this.api.call({
+                            method: 'DELETE',
+                            url: `https://api.bunny.net/storagezone/${id}`,
+                            params,
+                            operation: 'deleteZone'
+                        });
+                    }
+                },
+
+                listFiles: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        storageZoneName: string;
+                        storageHostname: string;
+                        path?: string;
+                        password: string;
+                    }) {
+                        const path = options.path ? `/${options.path}` : '';
+                        const headers = {
+                            'AccessKey': options.password
+                        };
+                        return await this.api.call({
+                            method: 'GET',
+                            url: `https://${options.storageHostname}/${options.storageZoneName}${path}/`,
+                            operation: 'listFiles',
+                            headers: headers
+                        });
+                    }
+                },
+
+                uploadFile: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        storageZoneName: string;
+                        storageHostname: string;
+                        path?: string;
+                        fileName: string;
+                        data: string | Buffer;
+                        password: string;
+                    }) {
+                        const path = options.path ? `/${options.path}` : '';
+                        const headers = {
+                            'AccessKey': options.password,
+                            'Content-Type': 'application/octet-stream'
+                        };
+                        return await this.api.call({
+                            method: 'PUT',
+                            url: `https://${options.storageHostname}/${options.storageZoneName}${path}/${options.fileName}`,
+                            data: options.data,
+                            operation: 'uploadFile',
+                            headers: headers
+                        });
+                    }
+                },
+
+                deleteFile: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        storageZoneName: string;
+                        storageHostname: string;
+                        path?: string;
+                        fileName: string;
+                        password: string;
+                    }) {
+                        const path = options.path ? `/${options.path}` : '';
+                        const headers = {
+                            'AccessKey': options.password
+                        };
+                        return await this.api.call({
+                            method: 'DELETE',
+                            url: `https://${options.storageHostname}/${options.storageZoneName}${path}/${options.fileName}`,
+                            operation: 'deleteFile',
+                            headers: headers
+                        });
+                    }
+                },
+
+                uploadDirectory: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        sourceDirectory: string;
+                        destinationDirectory?: string;
+                        storageZoneName: string;
+                        password: string;
+                        region?: string;
+                        cleanDestination?: 'simple' | 'avoid-deletes';
+                        maxConcurrentUploads?: number;
+                    }) {
+
+                        const uploadOptions: any = {
+                            storageZoneName: options.storageZoneName,
+                            accessKey: options.password,
+                            maxConcurrentUploads: options.maxConcurrentUploads || 10
+                        };
+
+                        if (options.region) {
+                            uploadOptions.region = options.region;
+                        }
+
+                        if (options.cleanDestination) {
+                            uploadOptions.cleanDestination = options.cleanDestination;
+                        }
+
+                        return await uploadToBunny(
+                            options.sourceDirectory,
+                            options.destinationDirectory || '',
+                            uploadOptions
+                        );
+                    }
+                }
+
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/bunny.net/api-storage'
+

package/caps/providers/bunny.net/api.ts

@@ -0,0 +1,95 @@
+
+import axios from 'axios';
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    // https://docs.bunny.net/api-reference/core
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/providers/bunny.net/WorkspaceConnectionConfig': {
+                as: '$ConnectionConfig'
+            },
+            '#': {
+
+                call: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, options: {
+                        method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+                        url: string;
+                        data?: any;
+                        params?: Record<string, string | number | boolean>;
+                        operation?: string;
+                        headers?: Record<string, string>;
+                    }) {
+                        const apiKey = options.headers?.AccessKey || await this.$ConnectionConfig.getConfigValue('apiKey')
+
+                        try {
+                            const config: any = {
+                                method: options.method,
+                                url: options.url,
+                                headers: options.headers || {
+                                    'AccessKey': apiKey
+                                }
+                            };
+
+                            if (options.data) {
+                                if (!config.headers['Content-Type']) {
+                                    config.headers['Content-Type'] = 'application/json';
+                                }
+                                config.data = options.data;
+                            }
+
+                            if (options.params) {
+                                config.params = options.params;
+                            }
+
+                            const response = await axios(config);
+                            return response.data;
+                        } catch (error: any) {
+                            if (error.response) {
+                                const errorData = error.response.data;
+                                const status = error.response.status;
+                                const statusText = error.response.statusText;
+
+                                const operationName = options.operation || options.method;
+                                console.error(`Bunny API Error [${operationName}]:`);
+                                console.error(`  Status: ${status} ${statusText}`);
+                                console.error(`  Response:`, JSON.stringify(errorData, null, 2));
+
+                                let errorMessage = `Bunny API ${operationName} failed: ${status} ${statusText}`;
+
+                                if (errorData && typeof errorData === 'object') {
+                                    if (errorData.Message) {
+                                        errorMessage += ` - ${errorData.Message}`;
+                                    } else if (errorData.ErrorKey) {
+                                        errorMessage += ` - ${errorData.ErrorKey}`;
+                                    } else {
+                                        errorMessage += ` - ${JSON.stringify(errorData)}`;
+                                    }
+                                }
+
+                                throw new Error(errorMessage);
+                            }
+                            throw error;
+                        }
+                    }
+                }
+
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/bunny.net/api'
+

package/caps/providers/dynadot.com/ProjectDeployment.ts

@@ -0,0 +1,202 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#t44/structs/ProjectDeploymentFact': {
+                as: '$StatusFact'
+            },
+            '#t44/structs/providers/dynadot.com/DomainFact': {
+                as: '$DomainFact'
+            },
+            '#t44/structs/ProjectDeploymentConfig': {
+                as: '$ProjectDeploymentConfig'
+            },
+            '#': {
+                domains: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: './api-domains'
+                },
+                deploy: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { projectionDir, alias, config, workspaceProjectName }: { projectionDir: string, alias: string, config: any, workspaceProjectName?: string }) {
+                        const domainConfig = config.provider.config.Domain
+                        const domainName = domainConfig.name
+                        const zones = domainConfig.zones || []
+
+                        console.log(`Deploying DNS for '${domainName}' via Dynadot ...`)
+
+                        const unsupportedApiTypes: string[] = []
+
+                        // Process only the zones we define — resolve jit() values
+                        const mainRecords: Array<{ recordType: string; value: string }> = []
+                        const subdomainRecords: Array<{ subdomain: string; record_type: string; value: string }> = []
+
+                        for (const zone of zones) {
+                            let value = zone.value
+                            if (typeof value === 'function') {
+                                value = await value()
+                            }
+
+                            const recordType = zone.type || 'cname'
+                            const subdomain = zone.subdomain || ''
+
+                            if (unsupportedApiTypes.includes(recordType.toLowerCase())) {
+                                console.log(`  ⚠ ${domainName} -> ${value} (${recordType.toUpperCase()}) — not settable via API`)
+                                console.log(`    Set manually at: https://www.dynadot.com/account/domain/name/${domainName}`)
+                                continue
+                            }
+
+                            if (subdomain === '' || subdomain === '@') {
+                                mainRecords.push({ recordType, value })
+                                console.log(`  ${domainName} -> ${value} (${recordType.toUpperCase()})`)
+                            } else {
+                                subdomainRecords.push({ subdomain, record_type: recordType, value })
+                                console.log(`  ${subdomain}.${domainName} -> ${value} (${recordType.toUpperCase()})`)
+                            }
+                        }
+
+                        if (mainRecords.length === 0 && subdomainRecords.length === 0) {
+                            console.log(`  No DNS records to update.`)
+                        } else {
+                            console.log(`  Setting DNS records (${mainRecords.length} main, ${subdomainRecords.length} sub) ...`)
+                            const setResult = await this.domains.setDns({
+                                name: domainName,
+                                records: subdomainRecords,
+                                mainDomains: mainRecords,
+                                addToCurrent: true
+                            })
+
+                            // v2 REST API returns { code: 200, message: "Success" }
+                            const code = setResult?.code
+                            const message = setResult?.message
+                            if (code !== 200) {
+                                console.log(`  DNS API response:`, JSON.stringify(setResult, null, 2))
+                                throw new Error(`Failed to set DNS: ${message || JSON.stringify(setResult)}`)
+                            }
+                        }
+
+                        console.log(`  DNS deployment complete: https://${domainName}`)
+
+                        const statusResult = {
+                            projectName: domainName,
+                            provider: 'dynadot.com',
+                            status: 'READY',
+                            publicUrl: `https://${domainName}`
+                        }
+                        await this.$StatusFact.set(domainName, statusResult)
+                    }
+                },
+                deprovision: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config }: { config: any }) {
+                        const domainName = config.provider.config.Domain.name
+
+                        console.log(`Deprovisioning DNS for '${domainName}' from Dynadot ...`)
+
+                        // Get current DNS records
+                        const currentDns = await this.domains.getDns({ name: domainName })
+                        const nsSettings = currentDns?.data?.domain_info?.[0]?.glue_info?.name_server_settings || {}
+                        const existingRecords = nsSettings?.sub_domains || []
+
+                        // Remove CNAME for root domain
+                        const filteredRecords = existingRecords.filter((r: any) => {
+                            return !(r.sub_host === '' && r.record_type === 'cname')
+                        })
+
+                        if (filteredRecords.length !== existingRecords.length) {
+                            console.log(`Removing root CNAME record ...`)
+                            await this.domains.setDns({
+                                name: domainName,
+                                records: filteredRecords
+                            })
+                            console.log(`Root CNAME record removed`)
+                        } else {
+                            console.log(`No root CNAME record found to remove`)
+                        }
+
+                        // Delete fact files
+                        console.log(`Deleting fact files ...`)
+                        try {
+                            await this.$DomainFact.delete(domainName)
+                            await this.$StatusFact.delete(domainName)
+                            console.log(`Fact files deleted`)
+                        } catch (error: any) {
+                            console.log(`Error deleting fact files: ${error.message}`)
+                        }
+
+                        console.log(`Deprovision complete`)
+                    }
+                },
+                status: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, { config, now, passive, deploymentName }: { config: any; now?: boolean; passive?: boolean; deploymentName?: string }) {
+                        const domainName = config.provider.config.Domain.name
+                        const factName = deploymentName || domainName
+
+                        if (!domainName) {
+                            return {
+                                projectName: factName || 'unknown',
+                                provider: 'dynadot.com',
+                                error: 'No domain name configured',
+                                rawDefinitionFilepaths: []
+                            }
+                        }
+
+                        const rawFilepaths = [
+                            this.$DomainFact.getRelativeFilepath(domainName)
+                        ]
+
+                        // Try to get cached status if not forcing refresh
+                        if (!now) {
+                            const cached = await this.$StatusFact.get(factName, rawFilepaths)
+                            if (cached) {
+                                return cached.data
+                            }
+                        }
+
+                        // In passive mode, don't call the provider if no cache exists
+                        if (passive) {
+                            return null
+                        }
+
+                        const dnsInfo = await this.domains.getDns({ name: domainName })
+                        const nsSettings = dnsInfo?.data?.domain_info?.[0]?.glue_info?.name_server_settings || {}
+                        const mainDomains = nsSettings.main_domains || []
+                        const subDomains = nsSettings.sub_domains || []
+
+                        // Check for main domain CNAME or ANAME record
+                        const mainCname = mainDomains.find((r: any) => ['cname', 'aname'].includes(r.record_type?.toLowerCase()))
+
+                        const result: Record<string, any> = {
+                            projectName: factName,
+                            provider: 'dynadot.com',
+                            status: mainCname ? 'READY' : 'NOT_CONFIGURED',
+                            publicUrl: mainCname ? `https://${domainName}` : undefined,
+                            providerPortalUrl: `https://www.dynadot.com/account/domain/name/${domainName}`,
+                            dnsRecords: { mainDomains, subDomains },
+                            rawDefinitionFilepaths: rawFilepaths
+                        }
+
+                        await this.$StatusFact.set(factName, result)
+
+                        return result
+                    }
+                }
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = 't44/caps/providers/dynadot.com/ProjectDeployment'