@stacksjs/ts-cloud-core 0.1.1

package/src/local/mock-aws.ts

@@ -0,0 +1,351 @@
+/**
+ * Mock AWS services for unit testing
+ * Provides in-memory implementations of AWS services without external dependencies
+ */
+
+export interface MockAWSConfig {
+  region?: string
+  credentials?: {
+    accessKeyId: string
+    secretAccessKey: string
+  }
+}
+
+/**
+ * Mock CloudFormation service
+ */
+export class MockCloudFormation {
+  private stacks: Map<string, any> = new Map()
+  private stackEvents: Map<string, any[]> = new Map()
+
+  async createStack(params: any): Promise<any> {
+    const stackId = `arn:aws:cloudformation:${params.region || 'us-east-1'}:123456789012:stack/${params.StackName}/${Date.now()}`
+
+    this.stacks.set(params.StackName, {
+      StackId: stackId,
+      StackName: params.StackName,
+      StackStatus: 'CREATE_IN_PROGRESS',
+      CreationTime: new Date().toISOString(),
+      TemplateBody: params.TemplateBody,
+      Parameters: params.Parameters || [],
+    })
+
+    this.addEvent(params.StackName, {
+      EventId: Date.now().toString(),
+      StackName: params.StackName,
+      LogicalResourceId: params.StackName,
+      ResourceType: 'AWS::CloudFormation::Stack',
+      Timestamp: new Date().toISOString(),
+      ResourceStatus: 'CREATE_IN_PROGRESS',
+    })
+
+    // Simulate async stack creation
+    setTimeout(() => {
+      const stack = this.stacks.get(params.StackName)
+      if (stack) {
+        stack.StackStatus = 'CREATE_COMPLETE'
+        this.addEvent(params.StackName, {
+          EventId: (Date.now() + 1).toString(),
+          StackName: params.StackName,
+          LogicalResourceId: params.StackName,
+          ResourceType: 'AWS::CloudFormation::Stack',
+          Timestamp: new Date().toISOString(),
+          ResourceStatus: 'CREATE_COMPLETE',
+        })
+      }
+    }, 100)
+
+    return { StackId: stackId }
+  }
+
+  async updateStack(params: any): Promise<any> {
+    const stack = this.stacks.get(params.StackName)
+
+    if (!stack) {
+      throw new Error(`Stack ${params.StackName} does not exist`)
+    }
+
+    stack.StackStatus = 'UPDATE_IN_PROGRESS'
+    stack.TemplateBody = params.TemplateBody || stack.TemplateBody
+
+    this.addEvent(params.StackName, {
+      EventId: Date.now().toString(),
+      StackName: params.StackName,
+      LogicalResourceId: params.StackName,
+      ResourceType: 'AWS::CloudFormation::Stack',
+      Timestamp: new Date().toISOString(),
+      ResourceStatus: 'UPDATE_IN_PROGRESS',
+    })
+
+    setTimeout(() => {
+      stack.StackStatus = 'UPDATE_COMPLETE'
+      this.addEvent(params.StackName, {
+        EventId: (Date.now() + 1).toString(),
+        StackName: params.StackName,
+        LogicalResourceId: params.StackName,
+        ResourceType: 'AWS::CloudFormation::Stack',
+        Timestamp: new Date().toISOString(),
+        ResourceStatus: 'UPDATE_COMPLETE',
+      })
+    }, 100)
+
+    return { StackId: stack.StackId }
+  }
+
+  async deleteStack(params: any): Promise<void> {
+    const stack = this.stacks.get(params.StackName)
+
+    if (!stack) {
+      throw new Error(`Stack ${params.StackName} does not exist`)
+    }
+
+    stack.StackStatus = 'DELETE_IN_PROGRESS'
+
+    this.addEvent(params.StackName, {
+      EventId: Date.now().toString(),
+      StackName: params.StackName,
+      LogicalResourceId: params.StackName,
+      ResourceType: 'AWS::CloudFormation::Stack',
+      Timestamp: new Date().toISOString(),
+      ResourceStatus: 'DELETE_IN_PROGRESS',
+    })
+
+    setTimeout(() => {
+      this.stacks.delete(params.StackName)
+      this.addEvent(params.StackName, {
+        EventId: (Date.now() + 1).toString(),
+        StackName: params.StackName,
+        LogicalResourceId: params.StackName,
+        ResourceType: 'AWS::CloudFormation::Stack',
+        Timestamp: new Date().toISOString(),
+        ResourceStatus: 'DELETE_COMPLETE',
+      })
+    }, 100)
+  }
+
+  async describeStacks(params: any): Promise<any> {
+    if (params.StackName) {
+      const stack = this.stacks.get(params.StackName)
+
+      if (!stack) {
+        throw new Error(`Stack ${params.StackName} does not exist`)
+      }
+
+      return {
+        Stacks: [stack],
+      }
+    }
+
+    return {
+      Stacks: Array.from(this.stacks.values()),
+    }
+  }
+
+  async describeStackEvents(params: any): Promise<any> {
+    const events = this.stackEvents.get(params.StackName) || []
+
+    return {
+      StackEvents: events,
+    }
+  }
+
+  private addEvent(stackName: string, event: any): void {
+    if (!this.stackEvents.has(stackName)) {
+      this.stackEvents.set(stackName, [])
+    }
+
+    this.stackEvents.get(stackName)!.unshift(event)
+  }
+
+  /**
+   * Reset mock state (useful for testing)
+   */
+  reset(): void {
+    this.stacks.clear()
+    this.stackEvents.clear()
+  }
+}
+
+/**
+ * Mock S3 service
+ */
+export class MockS3 {
+  private buckets: Map<string, Map<string, Buffer>> = new Map()
+
+  async createBucket(params: any): Promise<any> {
+    this.buckets.set(params.Bucket, new Map())
+
+    return {
+      Location: `/${params.Bucket}`,
+    }
+  }
+
+  async deleteBucket(params: any): Promise<void> {
+    this.buckets.delete(params.Bucket)
+  }
+
+  async putObject(params: any): Promise<any> {
+    let bucket = this.buckets.get(params.Bucket)
+
+    if (!bucket) {
+      bucket = new Map()
+      this.buckets.set(params.Bucket, bucket)
+    }
+
+    bucket.set(params.Key, Buffer.from(params.Body || ''))
+
+    return {
+      ETag: `"${Date.now()}"`,
+    }
+  }
+
+  async getObject(params: any): Promise<any> {
+    const bucket = this.buckets.get(params.Bucket)
+
+    if (!bucket) {
+      throw new Error(`Bucket ${params.Bucket} does not exist`)
+    }
+
+    const data = bucket.get(params.Key)
+
+    if (!data) {
+      throw new Error(`Object ${params.Key} does not exist`)
+    }
+
+    return {
+      Body: data,
+      ContentLength: data.length,
+    }
+  }
+
+  async deleteObject(params: any): Promise<void> {
+    const bucket = this.buckets.get(params.Bucket)
+
+    if (bucket) {
+      bucket.delete(params.Key)
+    }
+  }
+
+  async listObjects(params: any): Promise<any> {
+    const bucket = this.buckets.get(params.Bucket)
+
+    if (!bucket) {
+      throw new Error(`Bucket ${params.Bucket} does not exist`)
+    }
+
+    const objects = Array.from(bucket.keys()).map(key => ({
+      Key: key,
+      Size: bucket.get(key)!.length,
+      LastModified: new Date().toISOString(),
+    }))
+
+    return {
+      Contents: objects,
+    }
+  }
+
+  /**
+   * Reset mock state
+   */
+  reset(): void {
+    this.buckets.clear()
+  }
+}
+
+/**
+ * Mock DynamoDB service
+ */
+export class MockDynamoDB {
+  private tables: Map<string, any> = new Map()
+  private data: Map<string, Map<string, any>> = new Map()
+
+  async createTable(params: any): Promise<any> {
+    this.tables.set(params.TableName, {
+      TableName: params.TableName,
+      KeySchema: params.KeySchema,
+      AttributeDefinitions: params.AttributeDefinitions,
+      TableStatus: 'ACTIVE',
+      CreationDateTime: new Date().toISOString(),
+    })
+
+    this.data.set(params.TableName, new Map())
+
+    return {
+      TableDescription: this.tables.get(params.TableName),
+    }
+  }
+
+  async deleteTable(params: any): Promise<void> {
+    this.tables.delete(params.TableName)
+    this.data.delete(params.TableName)
+  }
+
+  async putItem(params: any): Promise<void> {
+    let tableData = this.data.get(params.TableName)
+
+    if (!tableData) {
+      tableData = new Map()
+      this.data.set(params.TableName, tableData)
+    }
+
+    const key = JSON.stringify(params.Item)
+    tableData.set(key, params.Item)
+  }
+
+  async getItem(params: any): Promise<any> {
+    const tableData = this.data.get(params.TableName)
+
+    if (!tableData) {
+      return {}
+    }
+
+    const key = JSON.stringify(params.Key)
+    const item = tableData.get(key)
+
+    return item ? { Item: item } : {}
+  }
+
+  async deleteItem(params: any): Promise<void> {
+    const tableData = this.data.get(params.TableName)
+
+    if (tableData) {
+      const key = JSON.stringify(params.Key)
+      tableData.delete(key)
+    }
+  }
+
+  async scan(params: any): Promise<any> {
+    const tableData = this.data.get(params.TableName)
+
+    if (!tableData) {
+      return { Items: [] }
+    }
+
+    return {
+      Items: Array.from(tableData.values()),
+    }
+  }
+
+  /**
+   * Reset mock state
+   */
+  reset(): void {
+    this.tables.clear()
+    this.data.clear()
+  }
+}
+
+/**
+ * Create mock AWS services
+ */
+export function createMockAWS(config?: MockAWSConfig): {
+  cloudformation: MockCloudFormation
+  s3: MockS3
+  dynamodb: MockDynamoDB
+} {
+  return {
+    cloudformation: new MockCloudFormation(),
+    s3: new MockS3(),
+    dynamodb: new MockDynamoDB(),
+  }
+}

package/src/modules/ai.ts

@@ -0,0 +1,340 @@
+import type {
+  IAMRole,
+  IAMManagedPolicy,
+} from '@stacksjs/ts-cloud-aws-types'
+import type { EnvironmentType } from '@stacksjs/ts-cloud-types'
+import { generateLogicalId, generateResourceName } from '../resource-naming'
+
+export interface BedrockRoleOptions {
+  slug: string
+  environment: EnvironmentType
+  name?: string
+  models?: string[]
+  allowStreaming?: boolean
+}
+
+export 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 class AI {
+  /**
+   * Create an IAM role for Bedrock access
+   */
+  static createBedrockRole(
+    servicePrincipal: string,
+    options: BedrockRoleOptions,
+  ): {
+      role: IAMRole
+      logicalId: string
+    } {
+    const {
+      slug,
+      environment,
+      name,
+      models = ['*'],
+      allowStreaming = true,
+    } = options
+
+    const resourceName = name || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'bedrock-role',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    // Build actions array
+    const actions = ['bedrock:InvokeModel']
+    if (allowStreaming) {
+      actions.push('bedrock:InvokeModelWithResponseStream')
+    }
+
+    // Build resource ARNs for models
+    const modelArns = models.map(model =>
+      model === '*'
+        ? 'arn:aws:bedrock:*::foundation-model/*'
+        : `arn:aws:bedrock:*::foundation-model/${model}`,
+    )
+
+    const role: IAMRole = {
+      Type: 'AWS::IAM::Role',
+      Properties: {
+        RoleName: resourceName,
+        AssumeRolePolicyDocument: {
+          Version: '2012-10-17',
+          Statement: [
+            {
+              Effect: 'Allow',
+              Principal: {
+                Service: servicePrincipal,
+              },
+              Action: 'sts:AssumeRole',
+            },
+          ],
+        },
+        Policies: [
+          {
+            PolicyName: `${resourceName}-policy`,
+            PolicyDocument: {
+              Version: '2012-10-17',
+              Statement: [
+                {
+                  Effect: 'Allow',
+                  Action: actions,
+                  Resource: modelArns,
+                },
+              ],
+            },
+          },
+        ],
+        Tags: [
+          { Key: 'Name', Value: resourceName },
+          { Key: 'Environment', Value: environment },
+        ],
+      },
+    }
+
+    return { role, logicalId }
+  }
+
+  /**
+   * Create an IAM policy for Bedrock model invocation
+   */
+  static createBedrockPolicy(options: BedrockPolicyOptions): {
+    policy: IAMManagedPolicy
+    logicalId: string
+  } {
+    const {
+      slug,
+      environment,
+      name,
+      models = ['*'],
+      allowInvoke = true,
+      allowStreaming = true,
+      allowAsync = false,
+    } = options
+
+    const resourceName = name || generateResourceName({
+      slug,
+      environment,
+      resourceType: 'bedrock-policy',
+    })
+
+    const logicalId = generateLogicalId(resourceName)
+
+    // Build actions array
+    const actions: string[] = []
+    if (allowInvoke) {
+      actions.push('bedrock:InvokeModel')
+    }
+    if (allowStreaming) {
+      actions.push('bedrock:InvokeModelWithResponseStream')
+    }
+    if (allowAsync) {
+      actions.push('bedrock:InvokeModelAsync')
+    }
+
+    // Build resource ARNs for models
+    const modelArns = models.map(model =>
+      model === '*'
+        ? 'arn:aws:bedrock:*::foundation-model/*'
+        : `arn:aws:bedrock:*::foundation-model/${model}`,
+    )
+
+    const policy: IAMManagedPolicy = {
+      Type: 'AWS::IAM::ManagedPolicy',
+      Properties: {
+        ManagedPolicyName: resourceName,
+        PolicyDocument: {
+          Version: '2012-10-17',
+          Statement: [
+            {
+              Sid: 'BedrockModelInvocation',
+              Effect: 'Allow',
+              Action: actions,
+              Resource: modelArns,
+            },
+          ],
+        },
+      },
+    }
+
+    return { policy, logicalId }
+  }
+
+  /**
+   * Enable Bedrock for Lambda function
+   * Returns a role with Bedrock permissions
+   */
+  static enableBedrockForLambda(options: BedrockRoleOptions): {
+    role: IAMRole
+    logicalId: string
+  } {
+    return AI.createBedrockRole('lambda.amazonaws.com', options)
+  }
+
+  /**
+   * Enable Bedrock for ECS task
+   * Returns a role with Bedrock permissions
+   */
+  static enableBedrockForEcs(options: BedrockRoleOptions): {
+    role: IAMRole
+    logicalId: string
+  } {
+    return AI.createBedrockRole('ecs-tasks.amazonaws.com', options)
+  }
+
+  /**
+   * Enable Bedrock for EC2 instance
+   * Returns a role with Bedrock permissions
+   */
+  static enableBedrockForEc2(options: BedrockRoleOptions): {
+    role: IAMRole
+    logicalId: string
+  } {
+    return AI.createBedrockRole('ec2.amazonaws.com', options)
+  }
+
+  /**
+   * Add Bedrock permissions to an existing role
+   */
+  static addBedrockPermissions(
+    role: IAMRole,
+    models: string[] = ['*'],
+    allowStreaming = true,
+  ): IAMRole {
+    // Build actions array
+    const actions = ['bedrock:InvokeModel']
+    if (allowStreaming) {
+      actions.push('bedrock:InvokeModelWithResponseStream')
+    }
+
+    // Build resource ARNs for models
+    const modelArns = models.map(model =>
+      model === '*'
+        ? 'arn:aws:bedrock:*::foundation-model/*'
+        : `arn:aws:bedrock:*::foundation-model/${model}`,
+    )
+
+    if (!role.Properties.Policies) {
+      role.Properties.Policies = []
+    }
+
+    // Add Bedrock policy
+    role.Properties.Policies.push({
+      PolicyName: 'bedrock-permissions',
+      PolicyDocument: {
+        Version: '2012-10-17',
+        Statement: [
+          {
+            Effect: 'Allow',
+            Action: actions,
+            Resource: modelArns,
+          },
+        ],
+      },
+    })
+
+    return role
+  }
+
+  /**
+   * Common Bedrock model IDs
+   */
+  static readonly Models = {
+    // Anthropic Claude Models
+    Claude3_5_Sonnet: 'anthropic.claude-3-5-sonnet-20241022-v2:0',
+    Claude3_5_Haiku: 'anthropic.claude-3-5-haiku-20241022-v1:0',
+    Claude3_Opus: 'anthropic.claude-3-opus-20240229-v1:0',
+    Claude3_Sonnet: 'anthropic.claude-3-sonnet-20240229-v1:0',
+    Claude3_Haiku: 'anthropic.claude-3-haiku-20240307-v1:0',
+
+    // Amazon Titan Models
+    TitanTextG1Express: 'amazon.titan-text-express-v1',
+    TitanTextG1Lite: 'amazon.titan-text-lite-v1',
+    TitanEmbedG1Text: 'amazon.titan-embed-text-v1',
+    TitanImageG1: 'amazon.titan-image-generator-v1',
+
+    // AI21 Labs Models
+    JurassicUltra: 'ai21.j2-ultra-v1',
+    JurassicMid: 'ai21.j2-mid-v1',
+
+    // Cohere Models
+    CommandText: 'cohere.command-text-v14',
+    CommandLight: 'cohere.command-light-text-v14',
+    EmbedEnglish: 'cohere.embed-english-v3',
+    EmbedMultilingual: 'cohere.embed-multilingual-v3',
+
+    // Meta Llama Models
+    Llama3_2_1B: 'meta.llama3-2-1b-instruct-v1:0',
+    Llama3_2_3B: 'meta.llama3-2-3b-instruct-v1:0',
+    Llama3_2_11B: 'meta.llama3-2-11b-instruct-v1:0',
+    Llama3_2_90B: 'meta.llama3-2-90b-instruct-v1:0',
+    Llama3_1_8B: 'meta.llama3-1-8b-instruct-v1:0',
+    Llama3_1_70B: 'meta.llama3-1-70b-instruct-v1:0',
+    Llama3_1_405B: 'meta.llama3-1-405b-instruct-v1:0',
+
+    // Mistral AI Models
+    Mistral7B: 'mistral.mistral-7b-instruct-v0:2',
+    Mixtral8x7B: 'mistral.mixtral-8x7b-instruct-v0:1',
+    MistralLarge: 'mistral.mistral-large-2402-v1:0',
+
+    // Stability AI Models
+    StableDiffusionXL: 'stability.stable-diffusion-xl-v1',
+  } as const
+
+  /**
+   * Common model groups for easier permission management
+   */
+  static readonly ModelGroups = {
+    AllClaude: [
+      'anthropic.claude-3-5-sonnet-20241022-v2:0',
+      'anthropic.claude-3-5-haiku-20241022-v1:0',
+      'anthropic.claude-3-opus-20240229-v1:0',
+      'anthropic.claude-3-sonnet-20240229-v1:0',
+      'anthropic.claude-3-haiku-20240307-v1:0',
+    ],
+    AllTitan: [
+      'amazon.titan-text-express-v1',
+      'amazon.titan-text-lite-v1',
+      'amazon.titan-embed-text-v1',
+      'amazon.titan-image-generator-v1',
+    ],
+    AllLlama: [
+      'meta.llama3-2-1b-instruct-v1:0',
+      'meta.llama3-2-3b-instruct-v1:0',
+      'meta.llama3-2-11b-instruct-v1:0',
+      'meta.llama3-2-90b-instruct-v1:0',
+      'meta.llama3-1-8b-instruct-v1:0',
+      'meta.llama3-1-70b-instruct-v1:0',
+      'meta.llama3-1-405b-instruct-v1:0',
+    ],
+    TextModels: [
+      'anthropic.claude-3-5-sonnet-20241022-v2:0',
+      'anthropic.claude-3-5-haiku-20241022-v1:0',
+      'amazon.titan-text-express-v1',
+      'meta.llama3-2-11b-instruct-v1:0',
+      'mistral.mistral-7b-instruct-v0:2',
+    ],
+    EmbeddingModels: [
+      'amazon.titan-embed-text-v1',
+      'cohere.embed-english-v3',
+      'cohere.embed-multilingual-v3',
+    ],
+    ImageModels: [
+      'amazon.titan-image-generator-v1',
+      'stability.stable-diffusion-xl-v1',
+    ],
+  } as const
+}