@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/modules/security.d.ts

@@ -0,0 +1,100 @@
+import type { ACMCertificate, KMSAlias, KMSKey, WAFv2IPSet, WAFv2WebACL } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface CertificateOptions {
+  domain: string
+  subdomains?: string[]
+  slug: string
+  environment: EnvironmentType
+  validationMethod?: 'DNS' | 'EMAIL'
+  hostedZoneId?: string
+}
+export declare interface KmsKeyOptions {
+  description: string
+  slug: string
+  environment: EnvironmentType
+  enableRotation?: boolean
+  multiRegion?: boolean
+}
+export declare interface FirewallOptions {
+  slug: string
+  environment: EnvironmentType
+  scope?: 'CLOUDFRONT' | 'REGIONAL'
+  defaultAction?: 'allow' | 'block'
+}
+export declare interface RateLimitRule {
+  name: string
+  priority: number
+  requestsPerWindow: number
+  aggregateKeyType?: 'IP' | 'FORWARDED_IP'
+}
+export declare interface GeoBlockRule {
+  name: string
+  priority: number
+  countryCodes: string[]
+}
+export declare interface IpBlockRule {
+  name: string
+  priority: number
+  ipAddresses: string[]
+  ipVersion?: 'IPV4' | 'IPV6'
+}
+export declare interface ManagedRuleGroup {
+  name: string
+  priority: number
+  vendorName: string
+  ruleName: string
+  excludedRules?: string[]
+}
+/**
+ * Security Module - ACM, KMS, WAF Management
+ * Provides clean API for creating and configuring security resources
+ */
+export declare class Security {
+  static createCertificate(options: CertificateOptions): {
+    certificate: ACMCertificate
+    logicalId: string
+  };
+  static createKmsKey(options: KmsKeyOptions): {
+    key: KMSKey
+    alias?: KMSAlias
+    logicalId: string
+    aliasId?: string
+  };
+  static createFirewall(options: FirewallOptions): {
+    webAcl: WAFv2WebACL
+    logicalId: string
+  };
+  static setRateLimit(webAcl: WAFv2WebACL, rule: RateLimitRule): WAFv2WebACL;
+  static blockCountries(webAcl: WAFv2WebACL, rule: GeoBlockRule): WAFv2WebACL;
+  static blockIpAddresses(webAcl: WAFv2WebACL, rule: IpBlockRule, slug: string, environment: EnvironmentType): {
+      webAcl: WAFv2WebACL
+      ipSet: WAFv2IPSet
+      ipSetLogicalId: string
+    };
+  static addManagedRules(webAcl: WAFv2WebACL, rule: ManagedRuleGroup): WAFv2WebACL;
+  static readonly ManagedRuleGroups: any;
+  static setPathRateLimit(webAcl: WAFv2WebACL, rule: RateLimitRule & { paths: string[] }): WAFv2WebACL;
+  static setHeaderRateLimit(webAcl: WAFv2WebACL, rule: RateLimitRule & { headerName: string, headerValue?: string }): WAFv2WebACL;
+  static protectLoginEndpoint(webAcl: WAFv2WebACL, options: {
+      loginPaths: string[]
+      priority: number
+      requestsPerMinute?: number
+    }): WAFv2WebACL;
+  static protectApiEndpoints(webAcl: WAFv2WebACL, options: {
+      apiPaths: string[]
+      priority: number
+      requestsPerMinute?: number
+    }): WAFv2WebACL;
+  static createProtectedFirewall(options: {
+    slug: string
+    environment: EnvironmentType
+    scope?: 'CLOUDFRONT' | 'REGIONAL'
+    enableBotControl?: boolean
+    enableRateLimiting?: boolean
+    rateLimitPerMinute?: number
+  }): {
+    webAcl: WAFv2WebACL
+    logicalId: string
+  };
+  static readonly RateLimitPresets: any;
+}

package/dist/modules/sms.d.ts

@@ -0,0 +1,52 @@
+export declare interface SmsConfig {
+  slug: string
+  environment: string
+  senderId?: string
+  originationNumber?: string
+  messageType?: 'TRANSACTIONAL' | 'PROMOTIONAL'
+  twoWayEnabled?: boolean
+  webhookUrl?: string
+}
+export declare class SMS {
+  static LambdaCode: { send: typeof sendHandler; receive: typeof receiveHandler; deliveryStatus: typeof deliveryStatusHandler };
+  static createPinpointApp(config: { slug: string; name?: string }): Record<string, any>;
+  static createSmsChannel(config: {
+    slug: string
+    applicationId: string | { Ref: string }
+    senderId?: string
+    shortCode?: string
+    enabled?: boolean
+  }): Record<string, any>;
+  static createSmsLambdaRole(config: { slug: string }): Record<string, any>;
+  static createSendLambda(config: {
+    slug: string
+    roleArn: string | { 'Fn::GetAtt': string[] }
+    pinpointAppId: string | { Ref: string }
+    messageLogTable?: string | { Ref: string }
+    senderId?: string
+    originationNumber?: string
+  }): Record<string, any>;
+  static createReceiveLambda(config: {
+    slug: string
+    roleArn: string | { 'Fn::GetAtt': string[] }
+    optOutTable?: string | { Ref: string }
+    messageLogTable?: string | { Ref: string }
+    notificationTopicArn?: string | { Ref: string }
+    webhookUrl?: string
+  }): Record<string, any>;
+  static createDeliveryStatusLambda(config: {
+    slug: string
+    roleArn: string | { 'Fn::GetAtt': string[] }
+    messageLogTable?: string | { Ref: string }
+    notificationTopicArn?: string | { Ref: string }
+    webhookUrl?: string
+  }): Record<string, any>;
+  static createMessageLogTable(config: { slug: string }): Record<string, any>;
+  static createOptOutTable(config: { slug: string }): Record<string, any>;
+  static createNotificationTopic(config: { slug: string }): Record<string, any>;
+  static createCompleteSetup(config: SmsConfig): {
+    resources: Record<string, any>
+    outputs: Record<string, any>
+  };
+}
+export default SMS;

package/dist/modules/storage.d.ts

@@ -0,0 +1,160 @@
+import { Fn } from '../intrinsic-functions';
+import type { BackupPlan, BackupSelection, BackupVault, S3Bucket, S3BucketPolicy } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+import type { IAMRole } from '@stacksjs/ts-cloud-aws-types';
+export declare interface BucketOptions {
+  name?: string
+  bucketName?: string
+  slug: string
+  environment: EnvironmentType
+  public?: boolean
+  versioning?: boolean
+  website?: boolean
+  encryption?: boolean
+  intelligentTiering?: boolean
+  cors?: CorsRule[]
+  lifecycleRules?: LifecycleRule[]
+}
+export declare interface CorsRule {
+  allowedOrigins: string[]
+  allowedMethods: string[]
+  allowedHeaders?: string[]
+  maxAge?: number
+}
+export declare interface LifecycleRule {
+  id: string
+  enabled: boolean
+  expirationDays?: number
+  transitions?: Array<{
+    days: number
+    storageClass: 'GLACIER' | 'DEEP_ARCHIVE' | 'INTELLIGENT_TIERING' | 'STANDARD_IA' | 'ONEZONE_IA'
+  }>
+}
+export declare interface S3NotificationConfig {
+  functionArn: string | { 'Fn::GetAtt': [string, string] }
+  events: Array<'s3:ObjectCreated:*' | 's3:ObjectCreated:Put' | 's3:ObjectCreated:Post' | 's3:ObjectCreated:Copy' | 's3:ObjectCreated:CompleteMultipartUpload' | 's3:ObjectRemoved:*' | 's3:ObjectRemoved:Delete' | 's3:ObjectRemoved:DeleteMarkerCreated'>
+  filter?: {
+    prefix?: string
+    suffix?: string
+  }
+}
+export declare interface BackupPlanOptions {
+  name: string
+  slug: string
+  environment: EnvironmentType
+  bucketLogicalIds: string[]
+  retentionDays: number
+  schedule?: string
+  vaultName?: string
+  enableContinuousBackup?: boolean
+  moveToColdStorageAfterDays?: number
+}
+/**
+ * Storage Module - S3 Bucket Management
+ * Provides clean API for creating and configuring S3 buckets
+ */
+export declare class Storage {
+  static createBucket(options: BucketOptions): { bucket: S3Bucket, bucketPolicy?: S3BucketPolicy, logicalId: string };
+  static enableVersioning(bucket: S3Bucket): S3Bucket;
+  static enableWebsiteHosting(bucket: S3Bucket, indexDocument?: any, errorDocument?: any): S3Bucket;
+  static setLifecycleRules(bucket: S3Bucket, rules: LifecycleRule[]): S3Bucket;
+  static enableIntelligentTiering(bucket: S3Bucket): S3Bucket;
+  static addLambdaNotification(bucket: S3Bucket, config: S3NotificationConfig): S3Bucket;
+  static readonly Notifications: any;
+  static createBackupPlan(options: BackupPlanOptions): {
+    vault: BackupVault
+    plan: BackupPlan
+    selection: BackupSelection
+    role: IAMRole
+    vaultLogicalId: string
+    planLogicalId: string
+    selectionLogicalId: string
+    roleLogicalId: string
+  };
+  static readonly BackupSchedules: any;
+  static readonly BackupRetention: any;
+  static createWwwRedirectBucket(options: {
+    slug: string
+    environment: EnvironmentType
+    sourceDomain: string // e.g., www.example.com
+    targetDomain: string // e.g., example.com
+    protocol?: 'http' | 'https'
+  }): { bucket: S3Bucket, bucketPolicy: S3BucketPolicy, logicalId: string };
+  static createDocsBucket(options: {
+    slug: string
+    environment: EnvironmentType
+    domain?: string
+  }): { bucket: S3Bucket, bucketPolicy?: S3BucketPolicy, logicalId: string };
+  static createEmailBucket(options: {
+    slug: string
+    environment: EnvironmentType
+  }): { bucket: S3Bucket, bucketPolicy: S3BucketPolicy, logicalId: string };
+  static docsExist(options?: {
+    projectRoot?: string
+    docsPaths?: string[]
+  }): {
+    exists: boolean
+    path: string | null
+    hasDistFolder: boolean
+    distPath: string | null
+  };
+  static createDocsBucketIfExists(options: {
+    slug: string
+    environment: EnvironmentType
+    domain?: string
+    projectRoot?: string
+    docsPaths?: string[]
+  }): {
+    bucket: S3Bucket | null
+    bucketPolicy?: S3BucketPolicy
+    logicalId: string | null
+    docsInfo: {
+      exists: boolean
+      path: string | null
+      hasDistFolder: boolean
+      distPath: string | null
+    }
+  };
+  static createPrivateBucket(options: {
+    slug: string
+    environment: EnvironmentType
+    enableVersioning?: boolean
+    retentionDays?: number
+    encryptionKeyArn?: string
+  }): { bucket: S3Bucket, logicalId: string };
+  static checkSourcePaths(options?: {
+    projectRoot?: string
+    paths?: {
+      web?: string
+      docs?: string
+      private?: string
+    }
+  }): {
+    web: { exists: boolean, path: string }
+    docs: { exists: boolean, path: string }
+    private: { exists: boolean, path: string }
+  };
+  static createDeploymentBuckets(options: {
+    slug: string
+    environment: EnvironmentType
+    domain?: string
+    projectRoot?: string
+    paths?: {
+      web?: string
+      docs?: string
+      private?: string
+    }
+  }): {
+    resources: Record<string, S3Bucket | S3BucketPolicy>
+    created: {
+      web: boolean
+      docs: boolean
+      private: boolean
+    }
+    sourcePaths: {
+      web: { exists: boolean, path: string }
+      docs: { exists: boolean, path: string }
+      private: { exists: boolean, path: string }
+    }
+  };
+}

package/dist/modules/workflow.d.ts

@@ -0,0 +1,205 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+import type { StepFunctionsStateMachine, IAMRole,  } from '@stacksjs/ts-cloud-aws-types';
+export declare interface StateMachineOptions {
+  slug: string
+  environment: EnvironmentType
+  stateMachineName?: string
+  type?: 'STANDARD' | 'EXPRESS'
+  definition: StateMachineDefinition
+  roleArn?: string
+  loggingConfiguration?: {
+    level: 'ALL' | 'ERROR' | 'FATAL' | 'OFF'
+    includeExecutionData?: boolean
+    destinations?: string[]
+  }
+  tracingConfiguration?: {
+    enabled: boolean
+  }
+}
+export declare interface StateMachineDefinition {
+  Comment?: string
+  StartAt: string
+  States: Record<string, State>
+  TimeoutSeconds?: number
+  Version?: string
+}
+export declare interface BaseState {
+  Type: 'Task' | 'Pass' | 'Wait' | 'Choice' | 'Parallel' | 'Map' | 'Succeed' | 'Fail'
+  Comment?: string
+  End?: boolean
+  Next?: string
+}
+export declare interface TaskState extends BaseState {
+  Type: 'Task'
+  Resource: string
+  Parameters?: Record<string, unknown>
+  ResultPath?: string | null
+  OutputPath?: string
+  InputPath?: string
+  TimeoutSeconds?: number
+  HeartbeatSeconds?: number
+  Retry?: RetryConfig[]
+  Catch?: CatchConfig[]
+}
+export declare interface PassState extends BaseState {
+  Type: 'Pass'
+  Result?: unknown
+  ResultPath?: string | null
+  Parameters?: Record<string, unknown>
+}
+export declare interface WaitState extends BaseState {
+  Type: 'Wait'
+  Seconds?: number
+  Timestamp?: string
+  SecondsPath?: string
+  TimestampPath?: string
+}
+export declare interface ChoiceState extends BaseState {
+  Type: 'Choice'
+  Choices: ChoiceRule[]
+  Default?: string
+}
+export declare interface ChoiceRule {
+  Variable: string
+  StringEquals?: string
+  StringLessThan?: string
+  StringGreaterThan?: string
+  NumericEquals?: number
+  NumericLessThan?: number
+  NumericGreaterThan?: number
+  BooleanEquals?: boolean
+  TimestampEquals?: string
+  TimestampLessThan?: string
+  TimestampGreaterThan?: string
+  IsPresent?: boolean
+  IsNull?: boolean
+  IsNumeric?: boolean
+  IsString?: boolean
+  IsBoolean?: boolean
+  IsTimestamp?: boolean
+  Next: string
+  And?: ChoiceRule[]
+  Or?: ChoiceRule[]
+  Not?: ChoiceRule
+}
+export declare interface ParallelState extends BaseState {
+  Type: 'Parallel'
+  Branches: StateMachineDefinition[]
+  ResultPath?: string | null
+  Retry?: RetryConfig[]
+  Catch?: CatchConfig[]
+}
+export declare interface MapState extends BaseState {
+  Type: 'Map'
+  ItemsPath?: string
+  Iterator: StateMachineDefinition
+  MaxConcurrency?: number
+  ResultPath?: string | null
+  Retry?: RetryConfig[]
+  Catch?: CatchConfig[]
+}
+export declare interface SucceedState extends BaseState {
+  Type: 'Succeed'
+}
+export declare interface FailState extends BaseState {
+  Type: 'Fail'
+  Error?: string
+  Cause?: string
+}
+export declare interface RetryConfig {
+  ErrorEquals: string[]
+  IntervalSeconds?: number
+  MaxAttempts?: number
+  BackoffRate?: number
+}
+export declare interface CatchConfig {
+  ErrorEquals: string[]
+  Next: string
+  ResultPath?: string
+}
+export type State = | TaskState
+  | PassState
+  | WaitState
+  | ChoiceState
+  | ParallelState
+  | MapState
+  | SucceedState
+  | FailState
+/**
+ * Workflow Module - Step Functions
+ * Provides clean API for orchestrating distributed applications and microservices
+ */
+export declare class Workflow {
+  static createStateMachine(options: StateMachineOptions): {
+    stateMachine: StepFunctionsStateMachine
+    logicalId: string
+    role?: IAMRole
+    roleLogicalId?: string
+  };
+  static createLambdaTask(functionArn: string, options?: {
+      parameters?: Record<string, unknown>
+      resultPath?: string | null
+      retry?: RetryConfig[]
+      catch?: CatchConfig[]
+      next?: string
+      end?: boolean
+    }): TaskState;
+  static createDynamoDBTask(action: 'GetItem' | 'PutItem' | 'UpdateItem' | 'DeleteItem', tableName: string, parameters: Record<string, unknown>, options?: {
+      resultPath?: string | null
+      retry?: RetryConfig[]
+      catch?: CatchConfig[]
+      next?: string
+      end?: boolean
+    }): TaskState;
+  static createSNSPublishTask(topicArn: string, message: Record<string, unknown>, options?: {
+      resultPath?: string | null
+      retry?: RetryConfig[]
+      catch?: CatchConfig[]
+      next?: string
+      end?: boolean
+    }): TaskState;
+  static createSQSSendMessageTask(queueUrl: string, messageBody: Record<string, unknown>, options?: {
+      resultPath?: string | null
+      retry?: RetryConfig[]
+      catch?: CatchConfig[]
+      next?: string
+      end?: boolean
+    }): TaskState;
+  static createPassState(options?: {
+    result?: unknown
+    resultPath?: string | null
+    parameters?: Record<string, unknown>
+    next?: string
+    end?: boolean
+  }): PassState;
+  static createWaitState(options: {
+    seconds?: number
+    timestamp?: string
+    secondsPath?: string
+    timestampPath?: string
+    next?: string
+    end?: boolean
+  }): WaitState;
+  static createChoiceState(choices: ChoiceRule[], defaultState?: string): ChoiceState;
+  static createParallelState(branches: StateMachineDefinition[], options?: {
+      resultPath?: string | null
+      retry?: RetryConfig[]
+      catch?: CatchConfig[]
+      next?: string
+      end?: boolean
+    }): ParallelState;
+  static createMapState(iterator: StateMachineDefinition, options?: {
+      itemsPath?: string
+      maxConcurrency?: number
+      resultPath?: string | null
+      retry?: RetryConfig[]
+      catch?: CatchConfig[]
+      next?: string
+      end?: boolean
+    }): MapState;
+  static createSucceedState(): SucceedState;
+  static createFailState(error?: string, cause?: string): FailState;
+  static readonly RetryPolicies: any;
+  static readonly CatchPolicies: any;
+  static readonly Patterns: any;
+}