@stacksjs/ts-cloud-core 0.1.2 → 0.1.6

package/src/local/mock-aws.ts

@@ -1,351 +0,0 @@
-/**
- * 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

@@ -1,340 +0,0 @@
-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
-}