@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/local/mock-aws.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Create mock AWS services
+ */
+export declare function createMockAWS(config?: MockAWSConfig): {
+  cloudformation: MockCloudFormation
+  s3: MockS3
+  dynamodb: MockDynamoDB
+};
+/**
+ * Mock AWS services for unit testing
+ * Provides in-memory implementations of AWS services without external dependencies
+ */
+export declare interface MockAWSConfig {
+  region?: string
+  credentials?: {
+    accessKeyId: string
+    secretAccessKey: string
+  }
+}
+/**
+ * Mock CloudFormation service
+ */
+export declare class MockCloudFormation {
+  private stacks: Map<string, any>;
+  private stackEvents: Map<string, any[]>;
+  createStack(params: any): Promise<any>;
+  updateStack(params: any): Promise<any>;
+  deleteStack(params: any): Promise<void>;
+  describeStacks(params: any): Promise<any>;
+  describeStackEvents(params: any): Promise<any>;
+  private addEvent(stackName: string, event: any): void;
+  reset(): void;
+}
+/**
+ * Mock S3 service
+ */
+export declare class MockS3 {
+  private buckets: Map<string, Map<string, Buffer>>;
+  createBucket(params: any): Promise<any>;
+  deleteBucket(params: any): Promise<void>;
+  putObject(params: any): Promise<any>;
+  getObject(params: any): Promise<any>;
+  deleteObject(params: any): Promise<void>;
+  listObjects(params: any): Promise<any>;
+  reset(): void;
+}
+/**
+ * Mock DynamoDB service
+ */
+export declare class MockDynamoDB {
+  private tables: Map<string, any>;
+  private data: Map<string, Map<string, any>>;
+  createTable(params: any): Promise<any>;
+  deleteTable(params: any): Promise<void>;
+  putItem(params: any): Promise<void>;
+  getItem(params: any): Promise<any>;
+  deleteItem(params: any): Promise<void>;
+  scan(params: any): Promise<any>;
+  reset(): void;
+}

package/dist/modules/ai.d.ts

@@ -0,0 +1,47 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+import type { IAMRole, IAMManagedPolicy,  } from '@stacksjs/ts-cloud-aws-types';
+export declare interface BedrockRoleOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  models?: string[]
+  allowStreaming?: boolean
+}
+export declare interface BedrockPolicyOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  models?: string[]
+  allowInvoke?: boolean
+  allowStreaming?: boolean
+  allowAsync?: boolean
+}
+/**
+ * AI Module - Amazon Bedrock
+ * Provides clean API for setting up Bedrock permissions and roles
+ */
+export declare class AI {
+  static createBedrockRole(servicePrincipal: string, options: BedrockRoleOptions): {
+      role: IAMRole
+      logicalId: string
+    };
+  static createBedrockPolicy(options: BedrockPolicyOptions): {
+    policy: IAMManagedPolicy
+    logicalId: string
+  };
+  static enableBedrockForLambda(options: BedrockRoleOptions): {
+    role: IAMRole
+    logicalId: string
+  };
+  static enableBedrockForEcs(options: BedrockRoleOptions): {
+    role: IAMRole
+    logicalId: string
+  };
+  static enableBedrockForEc2(options: BedrockRoleOptions): {
+    role: IAMRole
+    logicalId: string
+  };
+  static addBedrockPermissions(role: IAMRole, models?: string[], allowStreaming?: any): IAMRole;
+  static readonly Models: any;
+  static readonly ModelGroups: any;
+}

package/dist/modules/api.d.ts

@@ -0,0 +1,98 @@
+import type { ApiGatewayAuthorizer, ApiGatewayDeployment, ApiGatewayHttpApi, ApiGatewayRestApi, ApiGatewayStage,  } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface RestApiOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  apiName?: string
+  description?: string
+  endpointType?: 'EDGE' | 'REGIONAL' | 'PRIVATE'
+  binaryMediaTypes?: string[]
+  compressionSize?: number
+}
+export declare interface HttpApiOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  description?: string
+  corsEnabled?: boolean
+  corsOrigins?: string[]
+  corsMethods?: string[]
+  corsHeaders?: string[]
+  corsMaxAge?: number
+  corsAllowCredentials?: boolean
+}
+export declare interface WebSocketApiOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  description?: string
+}
+export declare interface StageOptions {
+  slug: string
+  environment: EnvironmentType
+  stageName?: string
+  description?: string
+  cacheEnabled?: boolean
+  cacheSize?: '0.5' | '1.6' | '6.1' | '13.5' | '28.4' | '58.2' | '118' | '237'
+  variables?: Record<string, string>
+  throttling?: {
+    burstLimit?: number
+    rateLimit?: number
+  }
+}
+export declare interface AuthorizerOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  type: 'TOKEN' | 'REQUEST' | 'COGNITO_USER_POOLS'
+  functionArn?: string
+  identitySource?: string
+  userPoolArns?: string[]
+  ttl?: number
+}
+/**
+ * API Gateway Module - REST, HTTP, and WebSocket APIs
+ * Provides clean API for creating and configuring API Gateway resources
+ */
+export declare class ApiGateway {
+  static createRestApi(options: RestApiOptions): {
+    restApi: ApiGatewayRestApi
+    logicalId: string
+  };
+  static createHttpApi(options: HttpApiOptions): {
+    httpApi: ApiGatewayHttpApi
+    logicalId: string
+  };
+  static createWebSocketApi(options: WebSocketApiOptions): {
+    webSocketApi: ApiGatewayHttpApi
+    logicalId: string
+  };
+  static createDeployment(restApiLogicalId: string, options: {
+      slug: string
+      environment: EnvironmentType
+      description?: string
+    }): {
+      deployment: ApiGatewayDeployment
+      logicalId: string
+    };
+  static createStage(restApiLogicalId: string, deploymentLogicalId: string, options: StageOptions): {
+      stage: ApiGatewayStage
+      logicalId: string
+    };
+  static createAuthorizer(restApiLogicalId: string, options: AuthorizerOptions): {
+      authorizer: ApiGatewayAuthorizer
+      logicalId: string
+    };
+  static setCors(httpApi: ApiGatewayHttpApi, options?: {
+      origins?: string[]
+      methods?: string[]
+      headers?: string[]
+      maxAge?: number
+      allowCredentials?: boolean
+    }): ApiGatewayHttpApi;
+  static addThrottling(stage: ApiGatewayStage, burstLimit?: number, rateLimit?: number): ApiGatewayStage;
+  static enableCaching(stage: ApiGatewayStage, cacheSize?: '0.5' | '1.6' | '6.1' | '13.5' | '28.4' | '58.2' | '118' | '237', ttl?: number): ApiGatewayStage;
+  static readonly CacheSizes: any;
+  static readonly ThrottlingPresets: any;
+}

package/dist/modules/auth.d.ts

@@ -0,0 +1,165 @@
+import type { CognitoUserPool, CognitoUserPoolClient, CognitoUserPoolDomain, CognitoIdentityPool, CognitoIdentityPoolRoleAttachment, IAMRole,  } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface UserPoolOptions {
+  slug: string
+  environment: EnvironmentType
+  userPoolName?: string
+  aliasAttributes?: ('email' | 'phone_number')[]
+  autoVerifiedAttributes?: ('email' | 'phone_number')[]
+  passwordPolicy?: PasswordPolicyOptions
+  mfaConfiguration?: 'OFF' | 'ON' | 'OPTIONAL'
+  emailConfiguration?: EmailConfigurationOptions
+  smsConfiguration?: SmsConfigurationOptions
+  lambdaTriggers?: LambdaTriggersOptions
+  userPoolAddOns?: {
+    advancedSecurityMode?: 'OFF' | 'AUDIT' | 'ENFORCED'
+  }
+  accountRecoverySetting?: {
+    recoveryMechanisms: Array<{
+      Name: 'verified_email' | 'verified_phone_number' | 'admin_only'
+      Priority: number
+    }>
+  }
+}
+export declare interface PasswordPolicyOptions {
+  minimumLength?: number
+  requireLowercase?: boolean
+  requireUppercase?: boolean
+  requireNumbers?: boolean
+  requireSymbols?: boolean
+  temporaryPasswordValidityDays?: number
+}
+export declare interface EmailConfigurationOptions {
+  emailSendingAccount?: 'COGNITO_DEFAULT' | 'DEVELOPER'
+  from?: string
+  replyToEmailAddress?: string
+  sourceArn?: string
+  configurationSet?: string
+}
+export declare interface SmsConfigurationOptions {
+  externalId: string
+  snsCallerArn: string
+}
+export declare interface LambdaTriggersOptions {
+  preSignUp?: string
+  postConfirmation?: string
+  preAuthentication?: string
+  postAuthentication?: string
+  customMessage?: string
+  defineAuthChallenge?: string
+  createAuthChallenge?: string
+  verifyAuthChallengeResponse?: string
+  preTokenGeneration?: string
+  userMigration?: string
+}
+export declare interface UserPoolClientOptions {
+  slug: string
+  environment: EnvironmentType
+  clientName?: string
+  generateSecret?: boolean
+  refreshTokenValidity?: number
+  accessTokenValidity?: number
+  idTokenValidity?: number
+  tokenValidityUnits?: {
+    RefreshToken?: 'seconds' | 'minutes' | 'hours' | 'days'
+    AccessToken?: 'seconds' | 'minutes' | 'hours' | 'days'
+    IdToken?: 'seconds' | 'minutes' | 'hours' | 'days'
+  }
+  readAttributes?: string[]
+  writeAttributes?: string[]
+  explicitAuthFlows?: string[]
+  preventUserExistenceErrors?: 'ENABLED' | 'LEGACY'
+  enableTokenRevocation?: boolean
+  callbackURLs?: string[]
+  logoutURLs?: string[]
+  allowedOAuthFlows?: ('code' | 'implicit' | 'client_credentials')[]
+  allowedOAuthScopes?: string[]
+  allowedOAuthFlowsUserPoolClient?: boolean
+  supportedIdentityProviders?: string[]
+}
+export declare interface UserPoolDomainOptions {
+  slug: string
+  environment: EnvironmentType
+  domain: string
+  customDomainConfig?: {
+    CertificateArn: string
+  }
+}
+export declare interface IdentityPoolOptions {
+  slug: string
+  environment: EnvironmentType
+  identityPoolName?: string
+  allowUnauthenticatedIdentities?: boolean
+  cognitoIdentityProviders?: Array<{
+    ClientId: string
+    ProviderName: string
+    ServerSideTokenCheck?: boolean
+  }>
+  supportedLoginProviders?: Record<string, string>
+  samlProviderARNs?: string[]
+  openIdConnectProviderARNs?: string[]
+}
+export declare interface IdentityPoolRoleAttachmentOptions {
+  slug: string
+  environment: EnvironmentType
+  authenticatedRole: string
+  unauthenticatedRole?: string
+  roleMappings?: Record<string, {
+    Type: 'Token' | 'Rules'
+    AmbiguousRoleResolution?: 'AuthenticatedRole' | 'Deny'
+    RulesConfiguration?: {
+      Rules: Array<{
+        Claim: string
+        MatchType: 'Equals' | 'Contains' | 'StartsWith' | 'NotEqual'
+        Value: string
+        RoleARN: string
+      }>
+    }
+  }>
+}
+/**
+ * Authentication Module - Cognito
+ * Provides clean API for user authentication and identity management
+ */
+export declare class Auth {
+  static createUserPool(options: UserPoolOptions): {
+    userPool: CognitoUserPool
+    logicalId: string
+  };
+  static createUserPoolClient(userPoolLogicalId: string, options: UserPoolClientOptions): {
+      client: CognitoUserPoolClient
+      logicalId: string
+    };
+  static createUserPoolDomain(userPoolLogicalId: string, options: UserPoolDomainOptions): {
+      domain: CognitoUserPoolDomain
+      logicalId: string
+    };
+  static createIdentityPool(options: IdentityPoolOptions): {
+    identityPool: CognitoIdentityPool
+    logicalId: string
+  };
+  static createIdentityPoolRoleAttachment(identityPoolLogicalId: string, options: IdentityPoolRoleAttachmentOptions): {
+      attachment: CognitoIdentityPoolRoleAttachment
+      logicalId: string
+    };
+  static createAuthenticatedRole(options: {
+    slug: string
+    environment: EnvironmentType
+    identityPoolLogicalId: string
+  }): {
+    role: IAMRole
+    logicalId: string
+  };
+  static createUnauthenticatedRole(options: {
+    slug: string
+    environment: EnvironmentType
+    identityPoolLogicalId: string
+  }): {
+    role: IAMRole
+    logicalId: string
+  };
+  static readonly PasswordPolicies: any;
+  static readonly AuthFlows: any;
+  static readonly OAuthScopes: any;
+  static readonly UseCases: any;
+}

package/dist/modules/cache.d.ts

@@ -0,0 +1,73 @@
+import type { ElastiCacheCluster, ElastiCacheParameterGroup, ElastiCacheReplicationGroup, ElastiCacheSubnetGroup,  } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface RedisOptions {
+  slug: string
+  environment: EnvironmentType
+  nodeType?: string
+  engineVersion?: string
+  port?: number
+  subnetIds?: string[]
+  securityGroupIds?: string[]
+  numCacheClusters?: number
+  automaticFailover?: boolean
+  multiAz?: boolean
+  clusterMode?: boolean
+  numNodeGroups?: number
+  replicasPerNodeGroup?: number
+  atRestEncryption?: boolean
+  transitEncryption?: boolean
+  authToken?: string
+  kmsKeyId?: string
+  snapshotRetentionDays?: number
+  snapshotWindow?: string
+  maintenanceWindow?: string
+}
+export declare interface MemcachedOptions {
+  slug: string
+  environment: EnvironmentType
+  nodeType?: string
+  engineVersion?: string
+  port?: number
+  numCacheNodes?: number
+  subnetIds?: string[]
+  securityGroupIds?: string[]
+  azMode?: 'single-az' | 'cross-az'
+  preferredAzs?: string[]
+  maintenanceWindow?: string
+}
+/**
+ * Cache Module - ElastiCache (Redis + Memcached)
+ * Provides clean API for creating Redis and Memcached clusters
+ */
+export declare class Cache {
+  static createRedis(options: RedisOptions): {
+    replicationGroup: ElastiCacheReplicationGroup
+    subnetGroup?: ElastiCacheSubnetGroup
+    logicalId: string
+    subnetGroupId?: string
+  };
+  static createMemcached(options: MemcachedOptions): {
+    cluster: ElastiCacheCluster
+    subnetGroup?: ElastiCacheSubnetGroup
+    logicalId: string
+    subnetGroupId?: string
+  };
+  static enableClusterMode(replicationGroup: ElastiCacheReplicationGroup, numNodeGroups?: number, replicasPerNodeGroup?: number): ElastiCacheReplicationGroup;
+  static createRedisParameterGroup(version: string, options: {
+      slug: string
+      environment: EnvironmentType
+      parameters?: Record<string, string>
+    }): {
+      parameterGroup: ElastiCacheParameterGroup
+      logicalId: string
+    };
+  static createMemcachedParameterGroup(version: string, options: {
+      slug: string
+      environment: EnvironmentType
+      parameters?: Record<string, string>
+    }): {
+      parameterGroup: ElastiCacheParameterGroup
+      logicalId: string
+    };
+  static readonly NodeTypes: any;
+}

package/dist/modules/cdn.d.ts

@@ -0,0 +1,125 @@
+import type { CloudFrontDistribution, CloudFrontOriginAccessControl, LambdaFunction, IAMRole } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface DistributionOptions {
+  slug: string
+  environment: EnvironmentType
+  origin: OriginConfig
+  customDomain?: string
+  certificateArn?: string
+  errorPages?: ErrorPageMapping[]
+  cachePolicy?: CachePolicyConfig
+  edgeFunctions?: EdgeFunctionConfig[]
+  http3?: boolean
+  comment?: string
+}
+export declare interface OriginConfig {
+  type?: 's3' | 'alb' | 'custom'
+  id?: string
+  originId?: string
+  domainName?: string
+  originPath?: string
+  customHeaders?: Record<string, string>
+  s3OriginAccessControl?: string
+}
+export declare interface ErrorPageMapping {
+  errorCode: number
+  responseCode?: number
+  responsePagePath?: string
+}
+export declare interface CachePolicyConfig {
+  minTTL?: number
+  maxTTL?: number
+  defaultTTL?: number
+}
+export declare interface EdgeFunctionConfig {
+  event: 'origin-request' | 'origin-response' | 'viewer-request' | 'viewer-response'
+  functionArn: string
+}
+/**
+ * CDN Module - CloudFront Distribution Management
+ * Provides clean API for creating and configuring CloudFront distributions
+ */
+export declare class CDN {
+  static createDistribution(options: DistributionOptions): {
+    distribution: CloudFrontDistribution
+    originAccessControl?: CloudFrontOriginAccessControl
+    logicalId: string
+  };
+  static setCustomDomain(distribution: CloudFrontDistribution, domain: string, certificateArn: string): CloudFrontDistribution;
+  static setErrorPages(distribution: CloudFrontDistribution, mappings: ErrorPageMapping[]): CloudFrontDistribution;
+  static enableHttp3(distribution: CloudFrontDistribution): CloudFrontDistribution;
+  static addEdgeFunction(distribution: CloudFrontDistribution, event: EdgeFunctionConfig['event'], functionArn: string): CloudFrontDistribution;
+  static setCachePolicy(distribution: CloudFrontDistribution, ttl: { min?: number, max?: number, default?: number }): CloudFrontDistribution;
+  static createSpaDistribution(options: Omit<DistributionOptions, 'errorPages'>): ReturnType<typeof CDN.createDistribution>;
+  static createDocsOriginRequestFunction(options: {
+    slug: string
+    environment: EnvironmentType
+  }): {
+    lambdaFunction: LambdaFunction
+    role: IAMRole
+    functionLogicalId: string
+    roleLogicalId: string
+    versionLogicalId: string
+  };
+  static createDocsDistribution(options: {
+    slug: string
+    environment: EnvironmentType
+    origin: OriginConfig
+    customDomain?: string
+    certificateArn?: string
+    lambdaEdgeFunctionArn?: string
+  }): {
+    distribution: CloudFrontDistribution
+    originAccessControl?: CloudFrontOriginAccessControl
+    logicalId: string
+  };
+  static createApiDistribution(options: {
+    slug: string
+    environment: EnvironmentType
+    albDomainName: string
+    customDomain?: string
+    certificateArn?: string
+    pathPattern?: string
+    forwardHeaders?: string[]
+    forwardCookies?: 'none' | 'all' | 'whitelist'
+    whitelistedCookies?: string[]
+    customOriginHeaders?: Record<string, string>
+  }): {
+    distribution: CloudFrontDistribution
+    logicalId: string
+  };
+  static createMultiOriginDistribution(options: {
+    slug: string
+    environment: EnvironmentType
+    s3BucketDomainName: string
+    albDomainName: string
+    apiPathPattern?: string
+    customDomain?: string
+    certificateArn?: string
+    customOriginHeaders?: Record<string, string>
+  }): {
+    distribution: CloudFrontDistribution
+    originAccessControl: CloudFrontOriginAccessControl
+    logicalId: string
+    oacLogicalId: string
+  };
+  static addAlbOrigin(distribution: CloudFrontDistribution, options: {
+      originId: string
+      domainName: string
+      pathPattern: string
+      customHeaders?: Record<string, string>
+      forwardHeaders?: string[]
+      cacheTtl?: { default: number, max: number, min: number }
+    }): CloudFrontDistribution;
+  static addOriginHeader(distribution: CloudFrontDistribution, originId: string, headerName: string, headerValue: string): CloudFrontDistribution;
+  static readonly EdgeFunctionTemplates: any;
+  static readonly Config: any;
+  static applyConfig(distribution: CloudFrontDistribution, config: {
+      ttl?: { min: number, max: number, default: number }
+      cookies?: 'none' | 'all' | 'allowList'
+      allowedCookies?: string[]
+      allowedMethods?: 'ALL' | 'GET_HEAD' | 'GET_HEAD_OPTIONS'
+      cachedMethods?: 'GET_HEAD' | 'GET_HEAD_OPTIONS'
+      compress?: boolean
+    }): CloudFrontDistribution;
+}

package/dist/modules/communication.d.ts

@@ -0,0 +1,98 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface CommunicationConfig {
+  slug: string
+  environment: EnvironmentType
+  region?: string
+  email?: EmailServiceConfig
+  phone?: PhoneServiceConfig
+  sms?: SmsServiceConfig
+}
+export declare interface EmailServiceConfig {
+  enabled: boolean
+  domain: string
+  mailboxes?: string[]
+  server?: {
+    enabled: boolean
+    scan?: boolean
+    storage?: {
+      retentionDays?: number
+      archiveAfterDays?: number
+    }
+  }
+  advanced?: {
+    search?: boolean // OpenSearch integration
+    threading?: boolean
+    scheduling?: boolean
+    analytics?: boolean
+    templates?: boolean
+    sharedMailboxes?: boolean
+    rules?: boolean
+  }
+  notifications?: {
+    newEmail?: boolean
+    bounces?: boolean
+    complaints?: boolean
+  }
+}
+export declare interface PhoneServiceConfig {
+  enabled: boolean
+  instanceAlias?: string
+  voicemail?: {
+    enabled: boolean
+    transcription?: boolean
+    maxDurationSeconds?: number
+  }
+  advanced?: {
+    recording?: boolean
+    analytics?: boolean
+    callbacks?: boolean
+  }
+  notifications?: {
+    incomingCall?: boolean
+    missedCall?: boolean
+    voicemail?: boolean
+  }
+}
+export declare interface SmsServiceConfig {
+  enabled: boolean
+  senderId?: string
+  originationNumber?: string
+  messageType?: 'TRANSACTIONAL' | 'PROMOTIONAL'
+  advanced?: {
+    campaigns?: boolean
+    analytics?: boolean
+    mms?: boolean
+    chatbot?: boolean
+    linkTracking?: boolean
+    abTesting?: boolean
+  }
+  optOut?: {
+    enabled: boolean
+    keywords?: string[]
+  }
+}
+/**
+ * Communication Module
+ *
+ * Generates complete CloudFormation stack for communication services
+ */
+export declare class Communication {
+  static generate(config: CommunicationConfig): Record<string, any>;
+  static private createLambdaExecutionRole(slug: string, environment: EnvironmentType): {
+    resources: Record<string, any>
+    roleArn: any
+    roleName: string
+  };
+  static private generateEmailResources(config: CommunicationConfig, roleArn: any): Record<string, any>;
+  static private generatePhoneResources(config: CommunicationConfig, roleArn: any): Record<string, any>;
+  static private generateSmsResources(config: CommunicationConfig, roleArn: any): Record<string, any>;
+  static InboundEmailCode: any;
+  static OutboundEmailCode: any;
+  static EmailSchedulerCode: any;
+  static EmailThreadingCode: any;
+  static IncomingCallCode: any;
+  static VoicemailCode: any;
+  static SendSmsCode: any;
+  static ReceiveSmsCode: any;
+}
+export default Communication;