@stacksjs/ts-cloud-core 0.1.6 → 0.1.7

package/dist/modules/permissions.d.ts

@@ -0,0 +1,132 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+import type { IAMAccessKey, IAMGroup, IAMInstanceProfile, IAMManagedPolicy, IAMRole, IAMUser,  } from '@stacksjs/ts-cloud-aws-types';
+export declare interface PolicyStatement {
+  sid?: string
+  effect?: 'Allow' | 'Deny'
+  actions: string | string[]
+  resources: string | string[]
+  conditions?: Record<string, unknown>
+}
+export declare interface UserOptions {
+  slug: string
+  environment: EnvironmentType
+  userName?: string
+  groups?: string[]
+  managedPolicyArns?: string[]
+}
+export declare interface RoleOptions {
+  slug: string
+  environment: EnvironmentType
+  roleName?: string
+  servicePrincipal?: string | string[]
+  awsPrincipal?: string | string[]
+  managedPolicyArns?: string[]
+}
+export declare interface GroupOptions {
+  slug: string
+  environment: EnvironmentType
+  groupName?: string
+  managedPolicyArns?: string[]
+}
+export declare interface ManagedPolicyOptions {
+  slug: string
+  environment: EnvironmentType
+  policyName?: string
+  description?: string
+  statements: PolicyStatement[]
+}
+/**
+ * Permissions Module - IAM (Identity and Access Management)
+ * Provides clean API for creating users, roles, policies, and groups
+ */
+export declare class Permissions {
+  static createUser(options: UserOptions): {
+    user: IAMUser
+    logicalId: string
+  };
+  static createRole(options: RoleOptions): {
+    role: IAMRole
+    logicalId: string
+  };
+  static createGroup(options: GroupOptions): {
+    group: IAMGroup
+    logicalId: string
+  };
+  static createPolicy(options: ManagedPolicyOptions): {
+    policy: IAMManagedPolicy
+    logicalId: string
+  };
+  static attachPolicyToRole(role: IAMRole, policyArn: string): IAMRole;
+  static attachPolicyToUser(user: IAMUser, policyArn: string): IAMUser;
+  static attachPolicyToGroup(group: IAMGroup, policyArn: string): IAMGroup;
+  static addInlinePolicyToRole(role: IAMRole, policyName: string, statements: PolicyStatement[]): IAMRole;
+  static addInlinePolicyToUser(user: IAMUser, policyName: string, statements: PolicyStatement[]): IAMUser;
+  static createAccessKey(userLogicalId: string, options: {
+      slug: string
+      environment: EnvironmentType
+      status?: 'Active' | 'Inactive'
+    }): {
+      accessKey: IAMAccessKey
+      logicalId: string
+    };
+  static createInstanceProfile(roleLogicalId: string, options: {
+      slug: string
+      environment: EnvironmentType
+      profileName?: string
+    }): {
+      instanceProfile: IAMInstanceProfile
+      logicalId: string
+    };
+  static readonly ManagedPolicies: any;
+  static readonly ServicePrincipals: any;
+  static createCiCdUser(options: {
+    slug: string
+    environment: EnvironmentType
+    permissions: {
+      s3Buckets?: string[]
+      cloudFrontDistributions?: string[]
+      ecrRepositories?: string[]
+      ecsServices?: string[]
+      cloudFormationStacks?: string[]
+      lambdaFunctions?: string[]
+      secretsManagerSecrets?: string[]
+    }
+    createAccessKey?: boolean
+  }): {
+    user: IAMUser
+    accessKey?: IAMAccessKey
+    policy: IAMManagedPolicy
+    userLogicalId: string
+    accessKeyLogicalId?: string
+    policyLogicalId: string
+    resources: Record<string, any>
+  };
+  static createCrossAccountRole(options: {
+    slug: string
+    environment: EnvironmentType
+    trustedAccountIds: string[]
+    externalId?: string
+    permissions: PolicyStatement[]
+    maxSessionDuration?: number
+  }): {
+    role: IAMRole
+    policy: IAMManagedPolicy
+    roleLogicalId: string
+    policyLogicalId: string
+    resources: Record<string, any>
+  };
+  static createCliUser(options: {
+    slug: string
+    environment: EnvironmentType
+    permissions?: 'readonly' | 'deploy' | 'admin'
+  }): {
+    user: IAMUser
+    accessKey: IAMAccessKey
+    policy?: IAMManagedPolicy
+    userLogicalId: string
+    accessKeyLogicalId: string
+    policyLogicalId?: string
+    resources: Record<string, any>
+  };
+  static readonly CiCdPolicies: any;
+}

package/dist/modules/phone.d.ts

@@ -0,0 +1,80 @@
+export declare interface PhoneConfig {
+  slug: string
+  environment: string
+  instanceAlias: string
+  inboundCallsEnabled?: boolean
+  outboundCallsEnabled?: boolean
+  voicemailEnabled?: boolean
+  transcriptionEnabled?: boolean
+  notificationTopicArn?: string
+  webhookUrl?: string
+}
+export declare class Phone {
+  static LambdaCode: {
+    incomingCall: string;
+    voicemail: string;
+    missedCall: string;
+  };
+  static createConnectInstance(config: PhoneConfig): Record<string, any>;
+  static createHoursOfOperation(config: {
+    slug: string
+    instanceArn: string
+    name: string
+    timezone: string
+    schedule: Array<{
+      day: string
+      startHour: number
+      startMinute: number
+      endHour: number
+      endMinute: number
+    }>
+  }): Record<string, any>;
+  static createQueue(config: {
+    slug: string
+    instanceArn: string
+    name: string
+    hoursOfOperationArn: string
+    maxContacts?: number
+  }): Record<string, any>;
+  static createContactFlow(config: {
+    slug: string
+    instanceArn: string
+    name: string
+    type: 'CONTACT_FLOW' | 'CUSTOMER_QUEUE' | 'CUSTOMER_HOLD' | 'CUSTOMER_WHISPER' | 'AGENT_HOLD' | 'AGENT_WHISPER' | 'OUTBOUND_WHISPER' | 'AGENT_TRANSFER' | 'QUEUE_TRANSFER'
+    content: string
+  }): Record<string, any>;
+  static createBasicIvrFlow(config: {
+    greeting: string
+    queueArn: string
+    voicemailLambdaArn?: string
+  }): string;
+  static createPhoneLambdaRole(config: { slug: string }): Record<string, any>;
+  static createIncomingCallLambda(config: {
+    slug: string
+    roleArn: string
+    notificationTopicArn?: string
+    callLogTable?: string
+    webhookUrl?: string
+  }): Record<string, any>;
+  static createVoicemailLambda(config: {
+    slug: string
+    roleArn: string
+    voicemailBucket: string
+    notificationTopicArn?: string
+    callLogTable?: string
+    transcriptionEnabled?: boolean
+  }): Record<string, any>;
+  static createMissedCallLambda(config: {
+    slug: string
+    roleArn: string
+    notificationTopicArn?: string
+    callLogTable?: string
+    webhookUrl?: string
+  }): Record<string, any>;
+  static createCallLogTable(config: { slug: string }): Record<string, any>;
+  static createCompleteSetup(config: PhoneConfig): {
+    resources: Record<string, any>
+    outputs: Record<string, any>
+  };
+}
+export default Phone;

package/dist/modules/queue.d.ts

@@ -0,0 +1,210 @@
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+import type { EventBridgeRule, SQSQueue,  } from '@stacksjs/ts-cloud-aws-types';
+/**
+ * Stacks framework job/action integration helpers
+ */
+export declare const StacksIntegration: {
+  loadJobs: typeof JobLoader.discoverJobs
+  loadActions: typeof JobLoader.discoverActions
+  generateScheduledJobs: typeof JobLoader.generateScheduledJobResources
+  generateRunner: typeof JobLoader.generateJobRunnerScript
+  paths: {
+    jobs: string
+    actions: string
+    runner: string
+  }
+};
+export declare interface QueueOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  delaySeconds?: number
+  visibilityTimeout?: number
+  messageRetentionPeriod?: number
+  maxMessageSize?: number
+  receiveMessageWaitTime?: number
+  fifo?: boolean
+  contentBasedDeduplication?: boolean
+  encrypted?: boolean
+  kmsKeyId?: string
+}
+export declare interface DeadLetterQueueOptions {
+  slug: string
+  environment: EnvironmentType
+  maxReceiveCount?: number
+}
+export declare interface ScheduleOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  description?: string
+  enabled?: boolean
+}
+export declare interface EcsScheduleOptions extends ScheduleOptions {
+  taskDefinitionArn: string
+  clusterArn: string
+  subnets: string[]
+  securityGroups?: string[]
+  assignPublicIp?: boolean
+  taskCount?: number
+  containerOverrides?: Array<{
+    name: string
+    environment?: Array<{
+      name: string
+      value: string
+    }>
+    command?: string[]
+  }>
+}
+export declare interface LambdaScheduleOptions extends ScheduleOptions {
+  functionArn: string
+  input?: Record<string, unknown>
+}
+export declare interface SqsTargetOptions extends ScheduleOptions {
+  queueArn: string
+  messageGroupId?: string
+}
+/**
+ * Job configuration type
+ */
+export declare interface JobConfiguration {
+  name: string
+  handler: string
+  retries: number
+  backoff: 'linear' | 'exponential' | 'fixed'
+  backoffDelay: number
+  maxDelay: number
+  timeout: number
+  jitter: boolean
+}
+/**
+ * Discovered job definition from file scanning
+ */
+export declare interface DiscoveredJob {
+  name: string
+  path: string
+  schedule?: string
+  handler: string
+  enabled: boolean
+  retries?: number
+  backoff?: 'linear' | 'exponential' | 'fixed'
+  timeout?: number
+  description?: string
+}
+/**
+ * Discovered action definition from file scanning
+ */
+export declare interface DiscoveredAction {
+  name: string
+  path: string
+  handler: string
+  description?: string
+}
+/**
+ * Queue & Scheduling Module - EventBridge + SQS
+ * Provides clean API for creating queues, cron jobs, and scheduled tasks
+ */
+export declare class Queue {
+  static createQueue(options: QueueOptions): {
+    queue: SQSQueue
+    logicalId: string
+  };
+  static createDeadLetterQueue(sourceQueueLogicalId: string, options: DeadLetterQueueOptions): {
+      deadLetterQueue: SQSQueue
+      updatedSourceQueue: SQSQueue
+      deadLetterLogicalId: string
+    };
+  static createSchedule(cronExpression: string, options: ScheduleOptions): {
+      rule: EventBridgeRule
+      logicalId: string
+    };
+  static scheduleEcsTask(cronExpression: string, roleArn: string, options: EcsScheduleOptions): {
+      rule: EventBridgeRule
+      logicalId: string
+    };
+  static scheduleLambda(cronExpression: string, options: LambdaScheduleOptions): {
+      rule: EventBridgeRule
+      logicalId: string
+    };
+  static scheduleSqsMessage(cronExpression: string, options: SqsTargetOptions): {
+      rule: EventBridgeRule
+      logicalId: string
+    };
+  static addTarget(rule: EventBridgeRule, target: {
+      id: string
+      arn: string
+      roleArn?: string
+      input?: Record<string, unknown>
+    }): EventBridgeRule;
+  static toCronExpression(expression: string): string;
+  static rateExpression(value: number, unit: 'minute' | 'minutes' | 'hour' | 'hours' | 'day' | 'days'): string;
+  static readonly CronExpressions: any;
+  static readonly RateExpressions: any;
+  static rateStringToExpression(rateString: string): string;
+  static readonly JobConfig: any;
+  static createJobContainerOverride(options: {
+    containerName: string
+    jobClass: string
+    jobData?: Record<string, unknown>
+    environment?: Record<string, string>
+  }): {
+    name: string
+    command: string[]
+    environment: Array<{ name: string, value: string }>
+  };
+  static createScheduledJob(options: {
+    slug: string
+    environment: EnvironmentType
+    schedule: string
+    jobClass: string
+    jobData?: Record<string, unknown>
+    taskDefinitionArn: string
+    clusterArn: string
+    subnets: string[]
+    securityGroups?: string[]
+    roleArn: string
+    containerName?: string
+  }): {
+    rule: EventBridgeRule
+    logicalId: string
+  };
+  static readonly QueuePresets: any;
+}
+/**
+ * Dynamic job and action loader for Stacks framework integration
+ */
+export declare class JobLoader {
+  static discoverJobs(options: {
+    projectRoot: string
+    jobsPath?: string
+  }): Promise<DiscoveredJob[]>;
+  static parseJobMetadata(content: string, name: string, path: string): DiscoveredJob | null;
+  static discoverActions(options: {
+    projectRoot: string
+    actionsPath?: string
+  }): Promise<DiscoveredAction[]>;
+  static parseActionMetadata(content: string, name: string, path: string): DiscoveredAction | null;
+  static generateScheduledJobResources(options: {
+    slug: string
+    environment: EnvironmentType
+    jobs: DiscoveredJob[]
+    taskDefinitionArn: string
+    clusterArn: string
+    subnets: string[]
+    securityGroups?: string[]
+    roleArn: string
+    containerName?: string
+  }): {
+    rules: Record<string, EventBridgeRule>
+    count: number
+  };
+  static generateJobRunnerScript(): string;
+  static generateJobManifest(options: {
+    projectRoot: string
+    jobsPath?: string
+  }): Promise<{
+    jobs: DiscoveredJob[]
+    scheduledCount: number
+    totalCount: number
+  }>;
+}

package/dist/modules/redirects.d.ts

@@ -0,0 +1,59 @@
+import type { CloudFrontFunction, S3Bucket, S3BucketPolicy } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface RedirectRule {
+  source: string
+  target: string
+  statusCode?: 301 | 302 | 307 | 308
+  preserveQueryString?: boolean
+}
+export declare interface DomainRedirectOptions {
+  slug: string
+  environment: EnvironmentType
+  sourceDomain: string
+  targetDomain: string
+  protocol?: 'http' | 'https'
+  preservePath?: boolean
+}
+export declare interface PathRedirectOptions {
+  slug: string
+  environment: EnvironmentType
+  rules: RedirectRule[]
+}
+/**
+ * Redirects Module - Domain and Path-based Redirects
+ * Provides clean API for URL redirects using S3 and CloudFront Functions
+ */
+export declare class Redirects {
+  static createDomainRedirectBucket(options: DomainRedirectOptions): {
+    bucket: S3Bucket
+    bucketPolicy: S3BucketPolicy
+    logicalId: string
+    policyLogicalId: string
+  };
+  static createPathRedirectFunction(options: PathRedirectOptions): {
+    function: CloudFrontFunction
+    logicalId: string
+    functionCode: string
+  };
+  static generateRedirectFunctionCode(rules: RedirectRule[]): string;
+  static readonly CommonRedirects: any;
+  static readonly Patterns: any;
+  static createRedirectSetup(options: {
+    slug: string
+    environment: EnvironmentType
+    domainRedirects?: DomainRedirectOptions[]
+    pathRedirects?: RedirectRule[]
+  }): {
+    resources: Record<string, any>
+    outputs: {
+      domainRedirectBuckets: string[]
+      pathRedirectFunctionLogicalId: string | null
+    }
+  };
+  static fromMapping(mapping: Record<string, string>, options?: { statusCode?: 301 | 302 | 307 | 308, preserveQueryString?: boolean }): RedirectRule[];
+  static validateRules(rules: RedirectRule[]): {
+    valid: boolean
+    errors: string[]
+    warnings: string[]
+  };
+}

package/dist/modules/registry.d.ts

@@ -0,0 +1,73 @@
+import type { ECRRepository, ECRLifecyclePolicy } from '@stacksjs/ts-cloud-aws-types';
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types';
+export declare interface RegistryOptions {
+  name: string
+  slug: string
+  environment: EnvironmentType
+  scanOnPush?: boolean
+  imageMutability?: 'MUTABLE' | 'IMMUTABLE'
+  encryption?: 'AES256' | 'KMS'
+  kmsKey?: string
+  lifecyclePolicy?: LifecyclePolicyConfig
+  tags?: Record<string, string>
+}
+export declare interface LifecyclePolicyConfig {
+  maxImageCount?: number
+  maxImageAgeDays?: number
+  untaggedImageExpireDays?: number
+}
+/**
+ * Registry Module - ECR Container Registry Management
+ * Provides clean API for creating and configuring ECR repositories
+ */
+export declare class Registry {
+  static createRepository(options: RegistryOptions): { repository: ECRRepository, logicalId: string };
+  static private generateLifecyclePolicy(config: LifecyclePolicyConfig): ECRLifecyclePolicy;
+  static readonly LifecyclePolicies: any;
+  static enableImmutableTags(repository: ECRRepository): ECRRepository;
+  static enableScanOnPush(repository: ECRRepository): ECRRepository;
+  static setLifecyclePolicy(repository: ECRRepository, config: LifecyclePolicyConfig): ECRRepository;
+  static addCrossAccountAccess(repository: ECRRepository, accountIds: string[]): ECRRepository;
+  static addLambdaAccess(repository: ECRRepository): ECRRepository;
+  static generateBunDockerfile(options: {
+    baseImage?: string
+    serverPath: string
+    port?: number
+    additionalDirs?: string[]
+    healthCheckEndpoint?: string
+    nodeCompatible?: boolean
+    envVars?: Record<string, string>
+    buildCommands?: string[]
+    runCommand?: string
+  }): string;
+  static generateDockerBuildCommands(options: {
+    repositoryUri: string
+    tag?: string
+    dockerfilePath?: string
+    context?: string
+    additionalTags?: string[]
+    buildArgs?: Record<string, string>
+    platform?: string
+    noCache?: boolean
+  }): {
+    build: string
+    tag: string[]
+    push: string[]
+    all: string[]
+  };
+  static generateEcrLoginCommand(region: string, accountId: string): string;
+  static buildRepositoryUri(options: {
+    accountId: string
+    region: string
+    repositoryName: string
+  }): string;
+  static generateImageTags(options: {
+    version?: string
+    gitSha?: string
+    gitBranch?: string
+    environment?: string
+    timestamp?: boolean
+  }): string[];
+  static readonly DeploymentWorkflow: any;
+  static readonly DockerfileTemplates: any;
+}

package/dist/modules/search.d.ts

@@ -0,0 +1,56 @@
+import type { OpenSearchDomain } from '@stacksjs/ts-cloud-aws-types';
+export declare interface SearchDomainOptions {
+  slug: string
+  environment: string
+  domainName?: string
+  engineVersion?: string
+  instanceType?: string
+  instanceCount?: number
+  volumeSize?: number
+  volumeType?: 'gp2' | 'gp3' | 'io1'
+  dedicatedMaster?: boolean
+  dedicatedMasterType?: string
+  dedicatedMasterCount?: number
+  multiAz?: boolean
+  availabilityZoneCount?: number
+  vpc?: {
+    subnetIds: Array<string | { Ref: string }>
+    securityGroupIds: Array<string | { Ref: string }>
+  }
+  encryption?: {
+    atRest?: boolean
+    kmsKeyId?: string | { Ref: string }
+    nodeToNode?: boolean
+  }
+  enforceHttps?: boolean
+  tlsSecurityPolicy?: 'Policy-Min-TLS-1-0-2019-07' | 'Policy-Min-TLS-1-2-2019-07'
+  advancedSecurity?: {
+    enabled: boolean
+    internalUserDatabase?: boolean
+    masterUserName?: string
+    masterUserPassword?: string
+    masterUserArn?: string | { Ref: string }
+  }
+  autoSnapshotHour?: number
+  autoTune?: boolean
+  tags?: Record<string, string>
+}
+export declare interface AccessPolicyOptions {
+  ipAddresses?: string[]
+  iamPrincipalArns?: Array<string | { Ref: string }>
+  allowAll?: boolean
+  vpcEndpoint?: boolean
+}
+/**
+ * Search class for OpenSearch/Elasticsearch operations
+ */
+export declare class Search {
+  static createDomain(options: SearchDomainOptions): {
+    domain: OpenSearchDomain
+    logicalId: string
+  };
+  static createAccessPolicy(domainArn: string | { 'Fn::GetAtt': [string, string] }, options: AccessPolicyOptions): Record<string, any>;
+  static readonly DomainPresets: any;
+  static readonly InstanceTypes: any;
+  static readonly EngineVersions: any;
+}

package/dist/modules/secrets.d.ts

@@ -0,0 +1,80 @@
+import type { SecretsManagerSecret, SecretsManagerSecretTargetAttachment, SecretsManagerRotationSchedule } from '@stacksjs/ts-cloud-aws-types';
+export declare interface SecretOptions {
+  slug: string
+  environment: string
+  secretName?: string
+  description?: string
+  secretString?: string
+  kmsKeyId?: string
+  tags?: Record<string, string>
+}
+export declare interface GeneratedSecretOptions {
+  slug: string
+  environment: string
+  secretName?: string
+  description?: string
+  excludeCharacters?: string
+  excludeLowercase?: boolean
+  excludeNumbers?: boolean
+  excludePunctuation?: boolean
+  excludeUppercase?: boolean
+  passwordLength?: number
+  requireEachIncludedType?: boolean
+  kmsKeyId?: string
+  tags?: Record<string, string>
+}
+export declare interface SecretTargetAttachmentOptions {
+  slug: string
+  environment: string
+  secretId: string
+  targetId: string
+  targetType: 'AWS::RDS::DBInstance' | 'AWS::RDS::DBCluster' | 'AWS::Redshift::Cluster' | 'AWS::DocDB::DBInstance' | 'AWS::DocDB::DBCluster'
+}
+export declare interface SecretRotationOptions {
+  slug: string
+  environment: string
+  secretId: string
+  rotationLambdaArn?: string
+  automaticallyAfterDays?: number
+  rotationType?: string
+  kmsKeyArn?: string
+  vpcSecurityGroupIds?: string
+  vpcSubnetIds?: string
+}
+/**
+ * Secrets Manager Module
+ */
+export declare class Secrets {
+  static createSecret(options: SecretOptions): {
+    secret: SecretsManagerSecret
+    logicalId: string
+  };
+  static createGeneratedSecret(options: GeneratedSecretOptions): {
+    secret: SecretsManagerSecret
+    logicalId: string
+  };
+  static createDatabaseSecret(options: {
+    slug: string
+    environment: string
+    secretName?: string
+    username: string
+    dbname?: string
+    engine?: string
+    host?: string
+    port?: number
+    kmsKeyId?: string
+  }): {
+    secret: SecretsManagerSecret
+    logicalId: string
+  };
+  static attachToDatabase(options: SecretTargetAttachmentOptions): {
+    attachment: SecretsManagerSecretTargetAttachment
+    logicalId: string
+  };
+  static enableRotation(options: SecretRotationOptions): {
+    rotation: SecretsManagerRotationSchedule
+    logicalId: string
+  };
+  static readonly SecretTypes: any;
+  static readonly RotationTypes: any;
+}