@stacksjs/ts-cloud 0.1.2 → 0.1.5

package/README.md

@@ -6,13 +6,13 @@
 <!-- [![npm downloads][npm-downloads-src]][npm-downloads-href] -->
 <!-- [![Codecov][codecov-src]][codecov-href] -->
 
-# ts-cloud
+# @stacksjs/ts-cloud
 
 > Zero-dependency AWS infrastructure as TypeScript. Deploy production-ready cloud infrastructure without AWS SDK or CLI.
 
 ## Overview
 
-ts-cloud is a modern infrastructure-as-code framework that lets you define AWS infrastructure using TypeScript configuration files. Unlike AWS CDK or Terraform, ts-cloud:
+@stacksjs/ts-cloud is a modern infrastructure-as-code framework that lets you define AWS infrastructure using TypeScript configuration files. Unlike AWS CDK or Terraform, @stacksjs/ts-cloud:
 
 - **Zero AWS Dependencies** - No AWS SDK, no AWS CLI. Direct AWS API calls only.
 - **Type-Safe Configuration** - Full TypeScript types for all AWS resources
@@ -55,6 +55,23 @@ Complete CloudFormation template builders for:
 - **Monitoring** - CloudWatch dashboards, alarms, and log groups
 - **Security** - ACM certificates, WAF rules, security groups
 
+### 🔒 Pre-Deployment Security Scanning
+
+Built-in secret detection to prevent accidental credential exposure:
+
+- **35+ Secret Patterns** - AWS keys, API tokens, private keys, database credentials
+- **Automatic Scanning** - Runs before every deployment
+- **Configurable Severity** - Block on critical, high, medium, or low findings
+- **CI/CD Ready** - Integrate security checks into your pipeline
+
+```bash
+# Scan for secrets before deploying
+cloud deploy:security-scan --source ./dist
+
+# Deploy with automatic security scanning
+cloud deploy  # Scans automatically before deployment
+```
+
 ### ☁️ Direct AWS Integration
 
 No SDK, no CLI - pure AWS Signature V4 API calls:
@@ -69,7 +86,7 @@ No SDK, no CLI - pure AWS Signature V4 API calls:
 ### Installation
 
 ```bash
-bun add ts-cloud
+bun add @stacksjs/ts-cloud
 ```
 
 ### Your First Deployment
@@ -77,7 +94,7 @@ bun add ts-cloud
 Create a `cloud.config.ts`:
 
 ```typescript
-import { createStaticSitePreset } from 'ts-cloud/presets'
+import { createStaticSitePreset } from '@stacksjs/ts-cloud/presets'
 
 export default createStaticSitePreset({
   name: 'My Website',
@@ -104,7 +121,7 @@ That's it! You now have:
 #### Full-Stack Application
 
 ```typescript
-import { createFullStackAppPreset } from 'ts-cloud/presets'
+import { createFullStackAppPreset } from '@stacksjs/ts-cloud/presets'
 
 export default createFullStackAppPreset({
   name: 'My App',
@@ -125,7 +142,7 @@ Includes:
 #### Serverless API
 
 ```typescript
-import { createApiBackendPreset } from 'ts-cloud/presets'
+import { createApiBackendPreset } from '@stacksjs/ts-cloud/presets'
 
 export default createApiBackendPreset({
   name: 'My API',
@@ -148,7 +165,7 @@ Includes:
 You can extend any preset with custom configuration:
 
 ```typescript
-import { createNodeJsServerPreset, extendPreset } from 'ts-cloud/presets'
+import { createNodeJsServerPreset, extendPreset } from '@stacksjs/ts-cloud/presets'
 
 export default extendPreset(
   createNodeJsServerPreset({
@@ -175,7 +192,7 @@ export default extendPreset(
 Combine multiple presets:
 
 ```typescript
-import { composePresets, createStaticSitePreset, createApiBackendPreset } from 'ts-cloud/presets'
+import { composePresets, createStaticSitePreset, createApiBackendPreset } from '@stacksjs/ts-cloud/presets'
 
 export default composePresets(
   createStaticSitePreset({ name: 'Frontend', slug: 'frontend', domain: 'example.com' }),
@@ -198,7 +215,7 @@ export default composePresets(
 Generate templates programmatically:
 
 ```typescript
-import { CloudFormationBuilder } from 'ts-cloud/cloudformation'
+import { CloudFormationBuilder } from '@stacksjs/ts-cloud/cloudformation'
 
 const builder = new CloudFormationBuilder(config)
 const template = builder.build()
@@ -211,7 +228,7 @@ console.log(JSON.stringify(template, null, 2))
 Use the AWS clients directly:
 
 ```typescript
-import { CloudFormationClient, S3Client, CloudFrontClient } from 'ts-cloud/aws'
+import { CloudFormationClient, S3Client, CloudFrontClient } from '@stacksjs/ts-cloud/aws'
 
 // CloudFormation
 const cfn = new CloudFormationClient('us-east-1')
@@ -236,6 +253,74 @@ await cloudfront.createInvalidation({
 })
 ```
 
+## DNS Providers
+
+@stacksjs/ts-cloud supports multiple DNS providers for domain management and SSL certificate validation:
+
+### Cloudflare
+
+1. Log in to your [Cloudflare Dashboard](https://dash.cloudflare.com/)
+2. Go to **My Profile** → **API Tokens** (or visit https://dash.cloudflare.com/profile/api-tokens)
+3. Click **Create Token**
+4. Use the **Edit zone DNS** template, or create a custom token with:
+   - **Permissions**: Zone → DNS → Edit
+   - **Zone Resources**: Include → All zones (or specific zones)
+5. Copy the generated token
+
+```bash
+export CLOUDFLARE_API_TOKEN="your-api-token-here"
+```
+
+### Porkbun
+
+1. Log in to your [Porkbun Dashboard](https://porkbun.com/account/api)
+2. Enable API access for your domain(s)
+3. Generate an API key pair
+
+```bash
+export PORKBUN_API_KEY="your-api-key"
+export PORKBUN_SECRET_KEY="your-secret-key"
+```
+
+### GoDaddy
+
+1. Log in to [GoDaddy Developer Portal](https://developer.godaddy.com/)
+2. Create a new API key
+3. Note both the key and secret
+
+```bash
+export GODADDY_API_KEY="your-api-key"
+export GODADDY_API_SECRET="your-api-secret"
+export GODADDY_ENVIRONMENT="production"  # or "ote" for testing
+```
+
+### Route53
+
+Uses AWS credentials from environment or ~/.aws/credentials:
+
+```bash
+export AWS_ACCESS_KEY_ID="your-access-key"
+export AWS_SECRET_ACCESS_KEY="your-secret-key"
+export AWS_REGION="us-east-1"
+export AWS_HOSTED_ZONE_ID="Z1234567890"  # Optional
+```
+
+### CLI Usage
+
+```bash
+# List domains
+cloud domain:list --provider cloudflare
+
+# List DNS records
+cloud dns:records example.com --provider cloudflare
+
+# Add a DNS record
+cloud dns:add example.com A 192.168.1.1 --name api --provider cloudflare
+
+# Generate SSL certificate with DNS validation
+cloud domain:ssl example.com --provider cloudflare
+```
+
 ## Development
 
 ```bash
@@ -264,7 +349,7 @@ bun run typecheck
 
 ### No Dependencies
 
-ts-cloud uses **zero external dependencies** for AWS operations:
+@stacksjs/ts-cloud uses **zero external dependencies** for AWS operations:
 
 - **AWS Signature V4** - Manual request signing for authentication
 - **Direct HTTPS** - Native `fetch()` for API calls
@@ -312,8 +397,8 @@ The MIT License (MIT). Please see [LICENSE](LICENSE.md) for more information.
 Made with 💙
 
 <!-- Badges -->
-[npm-version-src]: https://img.shields.io/npm/v/ts-cloud?style=flat-square
-[npm-version-href]: https://npmjs.com/package/ts-cloud
+[npm-version-src]: https://img.shields.io/npm/v/@stacksjs/ts-cloud?style=flat-square
+[npm-version-href]: https://npmjs.com/package/@stacksjs/ts-cloud
 [github-actions-src]: https://img.shields.io/github/actions/workflow/status/stacksjs/ts-cloud/ci.yml?style=flat-square&branch=main
 [github-actions-href]: https://github.com/stacksjs/ts-cloud/actions?query=workflow%3Aci
 

package/dist/aws/acm.d.ts

@@ -0,0 +1,129 @@
+import { AWSClient } from './client';
+import { Route53Client } from './route53';
+import type { DnsProvider, DnsProviderConfig } from '../dns/types';
+export declare interface CertificateDetail {
+  CertificateArn: string
+  DomainName: string
+  SubjectAlternativeNames?: string[]
+  Status: 'PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED'
+  Type?: 'IMPORTED' | 'AMAZON_ISSUED' | 'PRIVATE'
+  DomainValidationOptions?: {
+    DomainName: string
+    ValidationDomain?: string
+    ValidationStatus?: 'PENDING_VALIDATION' | 'SUCCESS' | 'FAILED'
+    ResourceRecord?: {
+      Name: string
+      Type: string
+      Value: string
+    }
+    ValidationMethod?: 'EMAIL' | 'DNS'
+  }[]
+  CreatedAt?: string
+  IssuedAt?: string
+  NotBefore?: string
+  NotAfter?: string
+}
+export declare class ACMClient {
+  private client: AWSClient;
+  private region: string;
+  constructor(region?: string);
+  requestCertificate(params: {
+    DomainName: string
+    SubjectAlternativeNames?: string[]
+    ValidationMethod?: 'EMAIL' | 'DNS'
+  }): Promise<{
+    CertificateArn: string
+  }>;
+  describeCertificate(params: {
+    CertificateArn: string
+  }): Promise<CertificateDetail>;
+  listCertificates(params?: {
+    CertificateStatuses?: ('PENDING_VALIDATION' | 'ISSUED' | 'INACTIVE' | 'EXPIRED' | 'VALIDATION_TIMED_OUT' | 'REVOKED' | 'FAILED')[]
+    MaxItems?: number
+    NextToken?: string
+  }): Promise<{
+    CertificateSummaryList: { CertificateArn: string, DomainName: string }[]
+    NextToken?: string
+  }>;
+  deleteCertificate(params: {
+    CertificateArn: string
+  }): Promise<void>;
+  listTagsForCertificate(params: {
+    CertificateArn: string
+  }): Promise<{ Tags: Array<{ Key: string, Value?: string }> }>;
+  addTagsToCertificate(params: {
+    CertificateArn: string
+    Tags: Array<{ Key: string, Value?: string }>
+  }): Promise<void>;
+  resendValidationEmail(params: {
+    CertificateArn: string
+    Domain: string
+    ValidationDomain: string
+  }): Promise<void>;
+  findCertificateByDomain(domainName: string): Promise<CertificateDetail | null>;
+  waitForCertificateValidation(certificateArn: string, maxAttempts?: any, delayMs?: any): Promise<CertificateDetail | null>;
+  getDnsValidationRecords(certificateArn: string): Promise<Array<{
+    domainName: string
+    recordName: string
+    recordType: string
+    recordValue: string
+  }>>;
+  requestCertificateWithSans(params: {
+    DomainName: string
+    IncludeWww?: boolean
+    IncludeWildcard?: boolean
+    AdditionalSans?: string[]
+  }): Promise<{ CertificateArn: string }>;
+  isCertificateValidForDomain(certificateArn: string, domainName: string): Promise<boolean>;
+}
+/**
+ * Helper class for ACM DNS validation with Route53 integration
+ * @deprecated Use UnifiedDnsValidator from 'ts-cloud/dns' for multi-provider support (Route53, Porkbun, GoDaddy)
+ */
+export declare class ACMDnsValidator {
+  private acm: ACMClient;
+  private route53: Route53Client;
+  private dnsProvider?: DnsProvider;
+  constructor(region?: string, dnsProviderConfig?: DnsProviderConfig);
+  requestAndValidate(params: {
+    domainName: string
+    hostedZoneId?: string
+    subjectAlternativeNames?: string[]
+    waitForValidation?: boolean
+    maxWaitMinutes?: number
+  }): Promise<{
+    certificateArn: string
+    validationRecords: Array<{
+      domainName: string
+      recordName: string
+      recordValue: string
+    }>
+  }>;
+  private waitForValidationOptions(certificateArn: string, maxAttempts?: any): Promise<void>;
+  createValidationRecords(params: {
+    certificateArn: string
+    hostedZoneId?: string
+    domain?: string
+  }): Promise<Array<{
+    domainName: string
+    recordName: string
+    recordValue: string
+    changeId?: string
+  }>>;
+  deleteValidationRecords(params: {
+    certificateArn: string
+    hostedZoneId?: string
+    domain?: string
+  }): Promise<void>;
+  findOrCreateCertificate(params: {
+    domainName: string
+    hostedZoneId?: string
+    subjectAlternativeNames?: string[]
+    waitForValidation?: boolean
+  }): Promise<{
+    certificateArn: string
+    isNew: boolean
+  }>;
+  hasExternalDnsProvider(): boolean;
+  getDnsProviderName(): string;
+}

package/dist/aws/application-autoscaling.d.ts

@@ -0,0 +1,282 @@
+import { AWSClient } from './client';
+export declare interface ScalableTarget {
+  ServiceNamespace: ServiceNamespace
+  ResourceId: string
+  ScalableDimension: ScalableDimension
+  MinCapacity: number
+  MaxCapacity: number
+  RoleARN?: string
+  CreationTime?: string
+  SuspendedState?: {
+    DynamicScalingInSuspended?: boolean
+    DynamicScalingOutSuspended?: boolean
+    ScheduledScalingSuspended?: boolean
+  }
+}
+export declare interface ScalingPolicy {
+  PolicyARN?: string
+  PolicyName: string
+  ServiceNamespace: ServiceNamespace
+  ResourceId: string
+  ScalableDimension: ScalableDimension
+  PolicyType: 'TargetTrackingScaling' | 'StepScaling'
+  StepScalingPolicyConfiguration?: StepScalingPolicyConfiguration
+  TargetTrackingScalingPolicyConfiguration?: TargetTrackingScalingPolicyConfiguration
+  Alarms?: Array<{
+    AlarmName: string
+    AlarmARN: string
+  }>
+  CreationTime?: string
+}
+export declare interface StepScalingPolicyConfiguration {
+  AdjustmentType: 'ChangeInCapacity' | 'PercentChangeInCapacity' | 'ExactCapacity'
+  StepAdjustments: Array<{
+    MetricIntervalLowerBound?: number
+    MetricIntervalUpperBound?: number
+    ScalingAdjustment: number
+  }>
+  MinAdjustmentMagnitude?: number
+  Cooldown?: number
+  MetricAggregationType?: 'Average' | 'Minimum' | 'Maximum'
+}
+export declare interface TargetTrackingScalingPolicyConfiguration {
+  TargetValue: number
+  PredefinedMetricSpecification?: {
+    PredefinedMetricType: MetricType
+    ResourceLabel?: string
+  }
+  CustomizedMetricSpecification?: {
+    MetricName: string
+    Namespace: string
+    Statistic: 'Average' | 'Minimum' | 'Maximum' | 'SampleCount' | 'Sum'
+    Unit?: string
+    Dimensions?: Array<{
+      Name: string
+      Value: string
+    }>
+  }
+  ScaleOutCooldown?: number
+  ScaleInCooldown?: number
+  DisableScaleIn?: boolean
+}
+export declare interface ScheduledAction {
+  ScheduledActionName: string
+  ScheduledActionARN?: string
+  ServiceNamespace: ServiceNamespace
+  Schedule: string
+  Timezone?: string
+  ResourceId: string
+  ScalableDimension: ScalableDimension
+  StartTime?: string
+  EndTime?: string
+  ScalableTargetAction?: {
+    MinCapacity?: number
+    MaxCapacity?: number
+  }
+  CreationTime?: string
+}
+export type ScalableDimension = | 'ecs:service:DesiredCount'
+  | 'dynamodb:table:ReadCapacityUnits'
+  | 'dynamodb:table:WriteCapacityUnits'
+  | 'dynamodb:index:ReadCapacityUnits'
+  | 'dynamodb:index:WriteCapacityUnits'
+  | 'rds:cluster:ReadReplicaCount'
+  | 'lambda:function:ProvisionedConcurrency'
+  | 'elasticache:replication-group:NodeGroups'
+  | 'elasticache:replication-group:Replicas'
+export type ServiceNamespace = | 'ecs'
+  | 'dynamodb'
+  | 'rds'
+  | 'lambda'
+  | 'elasticache'
+  | 'custom-resource'
+  | 'comprehend'
+  | 'kafka'
+  | 'sagemaker'
+export type MetricType = | 'ECSServiceAverageCPUUtilization'
+  | 'ECSServiceAverageMemoryUtilization'
+  | 'ALBRequestCountPerTarget'
+  | 'DynamoDBReadCapacityUtilization'
+  | 'DynamoDBWriteCapacityUtilization'
+  | 'RDSReaderAverageCPUUtilization'
+  | 'RDSReaderAverageDatabaseConnections'
+  | 'EC2SpotFleetRequestAverageCPUUtilization'
+  | 'EC2SpotFleetRequestAverageNetworkIn'
+  | 'EC2SpotFleetRequestAverageNetworkOut'
+  | 'SageMakerVariantInvocationsPerInstance'
+  | 'SageMakerVariantProvisionedConcurrencyUtilization'
+  | 'ElastiCachePrimaryEngineCPUUtilization'
+  | 'ElastiCacheReplicaEngineCPUUtilization'
+  | 'ElastiCacheDatabaseMemoryUsageCountedForEvictPercentage'
+  | 'LambdaProvisionedConcurrencyUtilization'
+  | 'CassandraReadCapacityUtilization'
+  | 'CassandraWriteCapacityUtilization'
+/**
+ * Application Auto Scaling client for ECS, DynamoDB, and other services
+ */
+export declare class ApplicationAutoScalingClient {
+  private client: AWSClient;
+  private region: string;
+  constructor(region?: string);
+  registerScalableTarget(options: {
+    serviceNamespace: ServiceNamespace
+    resourceId: string
+    scalableDimension: ScalableDimension
+    minCapacity: number
+    maxCapacity: number
+    roleARN?: string
+    suspendedState?: {
+      dynamicScalingInSuspended?: boolean
+      dynamicScalingOutSuspended?: boolean
+      scheduledScalingSuspended?: boolean
+    }
+  }): Promise<void>;
+  describeScalableTargets(options: {
+    serviceNamespace: ServiceNamespace
+    resourceIds?: string[]
+    scalableDimension?: ScalableDimension
+    maxResults?: number
+    nextToken?: string
+  }): Promise<{ ScalableTargets: ScalableTarget[], NextToken?: string }>;
+  deregisterScalableTarget(options: {
+    serviceNamespace: ServiceNamespace
+    resourceId: string
+    scalableDimension: ScalableDimension
+  }): Promise<void>;
+  putScalingPolicy(options: {
+    policyName: string
+    serviceNamespace: ServiceNamespace
+    resourceId: string
+    scalableDimension: ScalableDimension
+    policyType: 'TargetTrackingScaling' | 'StepScaling'
+    targetTrackingScalingPolicyConfiguration?: TargetTrackingScalingPolicyConfiguration
+    stepScalingPolicyConfiguration?: StepScalingPolicyConfiguration
+  }): Promise<{ PolicyARN: string, Alarms: Array<{ AlarmName: string, AlarmARN: string }> }>;
+  describeScalingPolicies(options: {
+    serviceNamespace: ServiceNamespace
+    policyNames?: string[]
+    resourceId?: string
+    scalableDimension?: ScalableDimension
+    maxResults?: number
+    nextToken?: string
+  }): Promise<{ ScalingPolicies: ScalingPolicy[], NextToken?: string }>;
+  deleteScalingPolicy(options: {
+    policyName: string
+    serviceNamespace: ServiceNamespace
+    resourceId: string
+    scalableDimension: ScalableDimension
+  }): Promise<void>;
+  putScheduledAction(options: {
+    scheduledActionName: string
+    serviceNamespace: ServiceNamespace
+    resourceId: string
+    scalableDimension: ScalableDimension
+    schedule: string
+    timezone?: string
+    startTime?: Date
+    endTime?: Date
+    scalableTargetAction?: {
+      minCapacity?: number
+      maxCapacity?: number
+    }
+  }): Promise<void>;
+  describeScheduledActions(options: {
+    serviceNamespace: ServiceNamespace
+    scheduledActionNames?: string[]
+    resourceId?: string
+    scalableDimension?: ScalableDimension
+    maxResults?: number
+    nextToken?: string
+  }): Promise<{ ScheduledActions: ScheduledAction[], NextToken?: string }>;
+  deleteScheduledAction(options: {
+    scheduledActionName: string
+    serviceNamespace: ServiceNamespace
+    resourceId: string
+    scalableDimension: ScalableDimension
+  }): Promise<void>;
+  describeScalingActivities(options: {
+    serviceNamespace: ServiceNamespace
+    resourceId?: string
+    scalableDimension?: ScalableDimension
+    maxResults?: number
+    nextToken?: string
+    includeNotScaledActivities?: boolean
+  }): Promise<{
+    ScalingActivities: Array<{
+      ActivityId: string
+      ServiceNamespace: string
+      ResourceId: string
+      ScalableDimension: string
+      Description: string
+      Cause: string
+      StartTime: string
+      EndTime?: string
+      StatusCode: 'Pending' | 'InProgress' | 'Successful' | 'Overridden' | 'Unfulfilled' | 'Failed'
+      StatusMessage?: string
+      Details?: string
+      NotScaledReasons?: Array<{
+        Code: string
+        MaxCapacity?: number
+        MinCapacity?: number
+        CurrentCapacity?: number
+      }>
+    }>
+    NextToken?: string
+  }>;
+  getECSServiceResourceId(clusterName: string, serviceName: string): string;
+  registerECSServiceScaling(options: {
+    clusterName: string
+    serviceName: string
+    minCapacity: number
+    maxCapacity: number
+  }): Promise<void>;
+  createECSCPUScalingPolicy(options: {
+    clusterName: string
+    serviceName: string
+    policyName: string
+    targetCPUPercent: number
+    scaleOutCooldown?: number
+    scaleInCooldown?: number
+    disableScaleIn?: boolean
+  }): Promise<{ PolicyARN: string, Alarms: Array<{ AlarmName: string, AlarmARN: string }> }>;
+  createECSMemoryScalingPolicy(options: {
+    clusterName: string
+    serviceName: string
+    policyName: string
+    targetMemoryPercent: number
+    scaleOutCooldown?: number
+    scaleInCooldown?: number
+    disableScaleIn?: boolean
+  }): Promise<{ PolicyARN: string, Alarms: Array<{ AlarmName: string, AlarmARN: string }> }>;
+  createECSRequestCountScalingPolicy(options: {
+    clusterName: string
+    serviceName: string
+    policyName: string
+    targetRequestsPerTarget: number
+    targetGroupArn: string
+    loadBalancerArn: string
+    scaleOutCooldown?: number
+    scaleInCooldown?: number
+    disableScaleIn?: boolean
+  }): Promise<{ PolicyARN: string, Alarms: Array<{ AlarmName: string, AlarmARN: string }> }>;
+  getECSServiceScalingPolicies(clusterName: string, serviceName: string): Promise<ScalingPolicy[]>;
+  removeECSServiceScaling(clusterName: string, serviceName: string): Promise<void>;
+  createECSScheduledScaling(options: {
+    clusterName: string
+    serviceName: string
+    actionName: string
+    schedule: string
+    timezone?: string
+    minCapacity?: number
+    maxCapacity?: number
+  }): Promise<void>;
+  getECSScalingActivities(clusterName: string, serviceName: string, maxResults?: any): Promise<Array<{
+    ActivityId: string
+    Description: string
+    Cause: string
+    StartTime: string
+    EndTime?: string
+    StatusCode: string
+    StatusMessage?: string
+  }>>;
+}