@stacksjs/ts-cloud 0.1.3 → 0.1.5

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import type { CloudOptions } from '@stacksjs/ts-cloud-types';
+export declare function getConfig(): Promise<CloudOptions>;
+export declare const defaultConfig: CloudOptions;
+// Alias for CLI usage
+export declare const loadCloudConfig: () => Promise<CloudOptions>;
+// For backwards compatibility - synchronous access with default fallback
+export declare const config: CloudOptions;

package/dist/deploy/index.d.ts

@@ -0,0 +1,2 @@
+export * from './static-site';
+export * from './static-site-external-dns';

package/dist/deploy/static-site-external-dns.d.ts

@@ -0,0 +1,51 @@
+import type { DnsProviderConfig } from '../dns/types';
+/**
+ * Generate CloudFormation template for static site infrastructure (without Route53)
+ */
+export declare function generateExternalDnsStaticSiteTemplate(config: {
+  bucketName: string
+  domain?: string
+  aliases?: string[]
+  certificateArn?: string
+  defaultRootObject?: string
+  errorDocument?: string
+}): object;
+/**
+ * Deploy a static site to AWS with external DNS provider
+ */
+export declare function deployStaticSiteWithExternalDns(config: ExternalDnsStaticSiteConfig): Promise<ExternalDnsDeployResult>;
+/**
+ * Full deployment with external DNS: infrastructure + files + cache invalidation
+ */
+export declare function deployStaticSiteWithExternalDnsFull(config: ExternalDnsStaticSiteConfig & {
+  sourceDir: string
+  cleanBucket?: boolean
+  onProgress?: (stage: string, detail?: string) => void
+}): Promise<ExternalDnsDeployResult>;
+export declare interface ExternalDnsStaticSiteConfig {
+  siteName: string
+  region?: string
+  domain: string
+  bucket?: string
+  certificateArn?: string
+  stackName?: string
+  defaultRootObject?: string
+  errorDocument?: string
+  cacheControl?: string
+  tags?: Record<string, string>
+  dnsProvider: DnsProviderConfig
+  skipDnsVerification?: boolean
+}
+export declare interface ExternalDnsDeployResult {
+  success: boolean
+  stackId?: string
+  stackName: string
+  bucket: string
+  distributionId?: string
+  distributionDomain?: string
+  domain?: string
+  certificateArn?: string
+  message: string
+  filesUploaded?: number
+  filesSkipped?: number
+}

package/dist/deploy/static-site.d.ts

@@ -0,0 +1,71 @@
+import type { DnsProviderConfig } from '../dns/types';
+/**
+ * Generate CloudFormation template for static site infrastructure
+ */
+export declare function generateStaticSiteTemplate(config: {
+  bucketName: string
+  domain?: string
+  certificateArn?: string
+  hostedZoneId?: string
+  defaultRootObject?: string
+  errorDocument?: string
+}): object;
+/**
+ * Deploy a static site to AWS
+ * Automatically routes to external DNS deployment when a non-Route53 dnsProvider is configured
+ */
+export declare function deployStaticSite(config: StaticSiteConfig): Promise<DeployResult>;
+/**
+ * Upload files to S3 bucket (only uploads changed files)
+ */
+export declare function uploadStaticFiles(options: UploadOptions): Promise<{ uploaded: number; skipped: number; errors: string[] }>;
+/**
+ * Invalidate CloudFront cache
+ */
+export declare function invalidateCache(distributionId: string): Promise<{ invalidationId: string }>;
+/**
+ * Delete static site infrastructure
+ */
+export declare function deleteStaticSite(stackName: string, region?: string): Promise<{ success: boolean; message: string }>;
+/**
+ * Full deployment: infrastructure + files + cache invalidation
+ */
+export declare function deployStaticSiteFull(config: StaticSiteConfig & {
+  sourceDir: string
+  cleanBucket?: boolean
+  onProgress?: (stage: string, detail?: string) => void
+}): Promise<DeployResult & { filesUploaded?: number; filesSkipped?: number }>;
+export declare interface StaticSiteConfig {
+  siteName: string
+  region?: string
+  domain?: string
+  subdomain?: string
+  baseDomain?: string
+  bucket?: string
+  hostedZoneId?: string
+  certificateArn?: string
+  stackName?: string
+  defaultRootObject?: string
+  errorDocument?: string
+  cacheControl?: string
+  tags?: Record<string, string>
+  dnsProvider?: DnsProviderConfig
+}
+export declare interface DeployResult {
+  success: boolean
+  stackId?: string
+  stackName: string
+  bucket: string
+  distributionId?: string
+  distributionDomain?: string
+  domain?: string
+  certificateArn?: string
+  message: string
+}
+export declare interface UploadOptions {
+  sourceDir: string
+  bucket: string
+  region: string
+  cacheControl?: string
+  onProgress?: (uploaded: number, total: number, file: string) => void
+}

package/dist/dns/cloudflare.d.ts

@@ -0,0 +1,52 @@
+import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordResult, DnsRecordType, ListRecordsResult,  } from './types';
+declare interface CloudflareRecord {
+  id: string
+  zone_id: string
+  zone_name: string
+  name: string
+  type: string
+  content: string
+  proxiable: boolean
+  proxied: boolean
+  ttl: number
+  locked: boolean
+  meta: Record<string, any>
+  comment?: string
+  tags?: string[]
+  created_on: string
+  modified_on: string
+  priority?: number
+}
+export declare class CloudflareProvider implements DnsProvider {
+  readonly name: any;
+  private apiToken: string;
+  private zoneCache: Map<string, string>;
+  constructor(apiToken: string);
+  private request<T>(method: string, endpoint: string, body?: any): Promise<CloudflareApiResponse<T>>;
+  private getRootDomain(domain: string): string;
+  private getZoneId(domain: string): Promise<string>;
+  private getFullRecordName(name: string, domain: string): string;
+  private toCloudflareRecord(record: DnsRecord, domain: string): Partial<CloudflareRecord>;
+  private fromCloudflareRecord(record: CloudflareRecord): DnsRecordResult;
+  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
+  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
+  canManageDomain(domain: string): Promise<boolean>;
+  listDomains(): Promise<string[]>;
+  getZoneDetails(domain: string): Promise<{
+    id: string
+    name: string
+    status: string
+    nameServers: string[]
+    paused: boolean
+  } | null>;
+  purgeCache(domain: string, options?: {
+    purgeEverything?: boolean
+    files?: string[]
+    tags?: string[]
+    hosts?: string[]
+  }): Promise<boolean>;
+  getRecordProxyStatus(domain: string, record: DnsRecord): Promise<boolean | null>;
+  setRecordProxyStatus(domain: string, record: DnsRecord, proxied: boolean): Promise<boolean>;
+}

package/dist/dns/godaddy.d.ts

@@ -0,0 +1,38 @@
+import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordResult, DnsRecordType, ListRecordsResult,  } from './types';
+declare interface GoDaddyRecord {
+  type: string
+  name: string
+  data: string
+  ttl: number
+  priority?: number
+}
+export declare class GoDaddyProvider implements DnsProvider {
+  readonly name: any;
+  private apiKey: string;
+  private apiSecret: string;
+  private baseUrl: string;
+  constructor(apiKey: string, apiSecret: string, environment?: 'production' | 'ote');
+  private request<T>(method: string, endpoint: string, body?: any): Promise<T>;
+  private getSubdomain(recordName: string, domain: string): string;
+  private getRootDomain(domain: string): string;
+  private toGoDaddyRecord(record: DnsRecord, domain: string): GoDaddyRecord;
+  private fromGoDaddyRecord(record: GoDaddyRecord, domain: string): DnsRecordResult;
+  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
+  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
+  canManageDomain(domain: string): Promise<boolean>;
+  listDomains(): Promise<string[]>;
+  getDomainDetails(domain: string): Promise<{
+    domain: string
+    status: string
+    nameServers?: string[]
+    expires?: string
+  } | null>;
+  updateNameServers(domain: string, nameservers: string[]): Promise<boolean>;
+  checkDomainAvailability(domain: string): Promise<{
+    available: boolean
+    price?: number
+    currency?: string
+  }>;
+}

package/dist/dns/index.d.ts

@@ -0,0 +1,45 @@
+import { CloudflareProvider } from './cloudflare';
+import { GoDaddyProvider } from './godaddy';
+import { PorkbunProvider } from './porkbun';
+import { Route53Provider } from './route53-adapter';
+import type { DnsProvider, DnsProviderConfig } from './types';
+/**
+ * Create a DNS provider from configuration
+ */
+export declare function createDnsProvider(config: DnsProviderConfig): DnsProvider;
+/**
+ * Auto-detect DNS provider for a domain
+ * Tries each provider to see which one can manage the domain
+ */
+export declare function detectDnsProvider(domain: string, configs: DnsProviderConfig[]): Promise<DnsProvider | null>;
+/**
+ * Default factory instance (can be configured globally)
+ */
+export declare const dnsProviders: DnsProviderFactory;
+/**
+ * DNS Provider factory with environment variable support
+ */
+export declare class DnsProviderFactory {
+  private providers: Map<string, DnsProvider>;
+  private configs: DnsProviderConfig[];
+  addConfig(config: DnsProviderConfig): this;
+  addRoute53(region?: string, hostedZoneId?: string): this;
+  addPorkbun(apiKey: string, secretKey: string): this;
+  addGoDaddy(apiKey: string, apiSecret: string, environment?: 'production' | 'ote'): this;
+  addCloudflare(apiToken: string): this;
+  loadFromEnv(): this;
+  getProvider(name: 'route53' | 'porkbun' | 'godaddy' | 'cloudflare'): DnsProvider | null;
+  getProviderForDomain(domain: string): Promise<DnsProvider | null>;
+  getAllProviders(): DnsProvider[];
+}
+export * from './types';
+export { PorkbunProvider } from './porkbun';
+export { GoDaddyProvider } from './godaddy';
+export { CloudflareProvider } from './cloudflare';
+export { Route53Provider } from './route53-adapter';
+export {
+  UnifiedDnsValidator,
+  createPorkbunValidator,
+  createGoDaddyValidator,
+  createRoute53Validator,
+} from './validator';

package/dist/dns/porkbun.d.ts

@@ -0,0 +1,18 @@
+import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordType, ListRecordsResult,  } from './types';
+export declare class PorkbunProvider implements DnsProvider {
+  readonly name: any;
+  private apiKey: string;
+  private secretKey: string;
+  constructor(apiKey: string, secretKey: string);
+  private request<T extends PorkbunApiResponse>(endpoint: string, additionalBody?: Record<string, any>): Promise<T>;
+  private getSubdomain(recordName: string, domain: string): string;
+  private getRootDomain(domain: string): string;
+  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
+  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
+  canManageDomain(domain: string): Promise<boolean>;
+  listDomains(): Promise<string[]>;
+  getNameServers(domain: string): Promise<string[]>;
+  updateNameServers(domain: string, nameservers: string[]): Promise<boolean>;
+}

package/dist/dns/route53-adapter.d.ts

@@ -0,0 +1,38 @@
+import { Route53Client } from '../aws/route53';
+import type { CreateRecordResult, DeleteRecordResult, DnsProvider, DnsRecord, DnsRecordType, ListRecordsResult,  } from './types';
+export declare class Route53Provider implements DnsProvider {
+  readonly name: any;
+  private client: Route53Client;
+  private hostedZoneCache: Map<string, string>;
+  private providedHostedZoneId?: string;
+  constructor(region?: string, hostedZoneId?: string);
+  private getRootDomain(domain: string): string;
+  private getHostedZoneId(domain: string): Promise<string | null>;
+  private normalizeName(name: string): string;
+  createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>;
+  deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>;
+  listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>;
+  canManageDomain(domain: string): Promise<boolean>;
+  listDomains(): Promise<string[]>;
+  getRoute53Client(): Route53Client;
+  createAliasRecord(params: {
+    domain: string
+    name: string
+    targetHostedZoneId: string
+    targetDnsName: string
+    evaluateTargetHealth?: boolean
+    type?: 'A' | 'AAAA'
+  }): Promise<CreateRecordResult>;
+  createCloudFrontAlias(params: {
+    domain: string
+    name: string
+    cloudFrontDomainName: string
+  }): Promise<CreateRecordResult>;
+  createAlbAlias(params: {
+    domain: string
+    name: string
+    albDnsName: string
+    region: string
+  }): Promise<CreateRecordResult>;
+}

package/{src/dns/types.ts → dist/dns/types.d.ts}

@@ -1,114 +1,77 @@
-/**
- * DNS Provider Types
- * Common interfaces for DNS provider abstraction
- */
-
-export type DnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'TXT' | 'MX' | 'NS' | 'SRV' | 'CAA'
-
-export interface DnsRecord {
+export declare interface DnsRecord {
   name: string
   type: DnsRecordType
   content: string
-  /** Alias for content - some providers use 'value' instead */
   value?: string
   ttl?: number
-  priority?: number // For MX and SRV records
-  weight?: number // For SRV records
-  port?: number // For SRV records
+  priority?: number
+  weight?: number
+  port?: number
 }
-
-export interface DnsRecordResult extends DnsRecord {
+export declare interface DnsRecordResult extends DnsRecord {
   id?: string
 }
-
-export interface CreateRecordResult {
+export declare interface CreateRecordResult {
   success: boolean
   id?: string
   message?: string
 }
-
-export interface DeleteRecordResult {
+export declare interface DeleteRecordResult {
   success: boolean
   message?: string
 }
-
-export interface ListRecordsResult {
+export declare interface ListRecordsResult {
   success: boolean
   records: DnsRecordResult[]
   message?: string
 }
-
 /**
  * Common DNS Provider interface
  * All DNS providers (Route53, Porkbun, GoDaddy, etc.) implement this
  */
-export interface DnsProvider {
-  /**
-   * Provider name for logging/identification
-   */
-  readonly name: string
-
-  /**
-   * Create a DNS record
-   */
+export declare interface DnsProvider {
+  name: string
   createRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>
-
-  /**
-   * Update an existing DNS record (upsert behavior)
-   */
   upsertRecord(domain: string, record: DnsRecord): Promise<CreateRecordResult>
-
-  /**
-   * Delete a DNS record
-   */
   deleteRecord(domain: string, record: DnsRecord): Promise<DeleteRecordResult>
-
-  /**
-   * List all DNS records for a domain
-   */
   listRecords(domain: string, type?: DnsRecordType): Promise<ListRecordsResult>
-
-  /**
-   * Check if the provider can manage this domain
-   */
   canManageDomain(domain: string): Promise<boolean>
-
-  /**
-   * List all domains managed by this provider
-   * Returns an array of domain names (e.g., ['example.com', 'mysite.org'])
-   */
   listDomains(): Promise<string[]>
 }
-
 /**
  * DNS Provider configuration types
  */
-export interface Route53ProviderConfig {
+export declare interface Route53ProviderConfig {
   provider: 'route53'
   region?: string
-  hostedZoneId?: string // Optional - will be auto-discovered if not provided
+  hostedZoneId?: string
 }
-
-export interface PorkbunProviderConfig {
+export declare interface PorkbunProviderConfig {
   provider: 'porkbun'
   apiKey: string
   secretKey: string
 }
-
-export interface GoDaddyProviderConfig {
+export declare interface GoDaddyProviderConfig {
   provider: 'godaddy'
   apiKey: string
   apiSecret: string
-  environment?: 'production' | 'ote' // OTE = test environment
+  environment?: 'production' | 'ote'
+}
+export declare interface CloudflareProviderConfig {
+  provider: 'cloudflare'
+  apiToken: string
 }
-
-export type DnsProviderConfig = Route53ProviderConfig | PorkbunProviderConfig | GoDaddyProviderConfig
-
 /**
  * Extended configuration for certificate validation
  */
-export interface CertificateValidationConfig {
+export declare interface CertificateValidationConfig {
   provider: DnsProviderConfig
   waitForValidation?: boolean
   maxWaitMinutes?: number
 }
+/**
+ * DNS Provider Types
+ * Common interfaces for DNS provider abstraction
+ */
+export type DnsRecordType = 'A' | 'AAAA' | 'CNAME' | 'TXT' | 'MX' | 'NS' | 'SRV' | 'CAA'
+export type DnsProviderConfig = Route53ProviderConfig | PorkbunProviderConfig | GoDaddyProviderConfig | CloudflareProviderConfig

package/dist/dns/validator.d.ts

@@ -0,0 +1,78 @@
+import { ACMClient } from '../aws/acm';
+import type { DnsProvider, DnsProviderConfig } from './types';
+/**
+ * Helper function to create a validator with Porkbun
+ */
+export declare function createPorkbunValidator(apiKey: string, secretKey: string, acmRegion?: string): UnifiedDnsValidator;
+/**
+ * Helper function to create a validator with GoDaddy
+ */
+export declare function createGoDaddyValidator(apiKey: string, apiSecret: string, acmRegion?: string, environment?: 'production' | 'ote'): UnifiedDnsValidator;
+/**
+ * Helper function to create a validator with Route53
+ */
+export declare function createRoute53Validator(region?: string, hostedZoneId?: string, acmRegion?: string): UnifiedDnsValidator;
+export declare interface ValidationRecord {
+  domainName: string
+  recordName: string
+  recordType: string
+  recordValue: string
+}
+export declare interface CertificateValidationResult {
+  certificateArn: string
+  validationRecords: ValidationRecord[]
+  isNew: boolean
+  status: 'pending' | 'issued' | 'failed'
+}
+/**
+ * Unified DNS Validator
+ * Handles ACM certificate validation with any DNS provider
+ */
+export declare class UnifiedDnsValidator {
+  private acm: ACMClient;
+  private dnsProvider: DnsProvider;
+  constructor(dnsProvider: DnsProvider | DnsProviderConfig, acmRegion?: string);
+  getProvider(): DnsProvider;
+  requestAndValidate(params: {
+    domainName: string
+    subjectAlternativeNames?: string[]
+    waitForValidation?: boolean
+    maxWaitMinutes?: number
+  }): Promise<CertificateValidationResult>;
+  createValidationRecords(params: {
+    certificateArn: string
+    domain: string
+  }): Promise<{
+    success: boolean
+    records: ValidationRecord[]
+    errors: string[]
+  }>;
+  deleteValidationRecords(params: {
+    certificateArn: string
+    domain: string
+  }): Promise<{
+    success: boolean
+    errors: string[]
+  }>;
+  findOrCreateCertificate(params: {
+    domainName: string
+    subjectAlternativeNames?: string[]
+    waitForValidation?: boolean
+    maxWaitMinutes?: number
+  }): Promise<CertificateValidationResult>;
+  requestCertificateWithCommonSans(params: {
+    domainName: string
+    includeWww?: boolean
+    includeWildcard?: boolean
+    additionalSans?: string[]
+    waitForValidation?: boolean
+  }): Promise<CertificateValidationResult>;
+  private waitForValidationOptions(certificateArn: string, maxAttempts?: any): Promise<void>;
+  getCertificateStatus(certificateArn: string): Promise<{
+    status: string
+    domainValidations: Array<{
+      domain: string
+      status: string
+    }>
+  }>;
+}

package/dist/generators/index.d.ts

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

package/dist/generators/infrastructure.d.ts

@@ -0,0 +1,30 @@
+import { TemplateBuilder,  } from '@stacksjs/ts-cloud-core';
+import type { CloudConfig } from '@stacksjs/ts-cloud-types';
+export declare interface GenerationOptions {
+  config: CloudConfig
+  environment: 'production' | 'staging' | 'development'
+  modules?: string[]
+}
+export declare class InfrastructureGenerator {
+  private builder: TemplateBuilder;
+  private config: CloudConfig;
+  private environment: 'production' | 'staging' | 'development';
+  private mergedConfig: CloudConfig;
+  constructor(options: GenerationOptions);
+  private mergeEnvironmentConfig(): CloudConfig;
+  private shouldDeploy(resource: any): boolean;
+  generate(): this;
+  private applyGlobalTags(tags: Record<string, string>): void;
+  private generateServerless(slug: string, env: typeof this.environment): void;
+  private generateServer(slug: string, env: typeof this.environment): void;
+  private generateSharedInfrastructure(slug: string, env: typeof this.environment): void;
+  private generateRealtimeResources(slug: string, env: typeof this.environment): void;
+  private generateConnectHandlerCode(): string;
+  private generateDisconnectHandlerCode(): string;
+  private generateMessageHandlerCode(): string;
+  private generateRealtimeServerResources(slug: string, env: typeof this.environment): void;
+  generateBroadcastConfig(): string;
+  toYAML(): string;
+  toJSON(): string;
+  getBuilder(): TemplateBuilder;
+}