@stacksjs/ts-cloud-core 0.1.3 → 0.1.6

package/src/aws/cloudformation.ts

@@ -1,421 +0,0 @@
-/**
- * AWS CloudFormation API Client
- * Direct API calls without AWS SDK dependency
- */
-
-import type { AWSCredentials } from './credentials'
-import { resolveCredentials } from './credentials'
-import { makeAWSRequest, parseXMLResponse } from './signature'
-
-export interface CloudFormationStack {
-  StackName: string
-  StackId?: string
-  StackStatus?: string
-  CreationTime?: string
-  LastUpdatedTime?: string
-  StackStatusReason?: string
-  Description?: string
-  Parameters?: Array<{ ParameterKey: string, ParameterValue: string }>
-  Outputs?: Array<{ OutputKey: string, OutputValue: string, Description?: string }>
-  Tags?: Array<{ Key: string, Value: string }>
-}
-
-export interface CreateStackOptions {
-  stackName: string
-  templateBody?: string
-  templateURL?: string
-  parameters?: Record<string, string>
-  capabilities?: string[]
-  tags?: Record<string, string>
-  timeoutInMinutes?: number
-  onFailure?: 'DO_NOTHING' | 'ROLLBACK' | 'DELETE'
-}
-
-export interface UpdateStackOptions {
-  stackName: string
-  templateBody?: string
-  templateURL?: string
-  parameters?: Record<string, string>
-  capabilities?: string[]
-  tags?: Record<string, string>
-}
-
-export interface StackEvent {
-  EventId: string
-  StackName: string
-  LogicalResourceId: string
-  PhysicalResourceId?: string
-  ResourceType: string
-  Timestamp: string
-  ResourceStatus: string
-  ResourceStatusReason?: string
-}
-
-/**
- * CloudFormation API Client
- */
-export class CloudFormationClient {
-  private credentials: AWSCredentials | null = null
-  private region: string
-
-  constructor(
-    region: string = 'us-east-1',
-    private readonly profile: string = 'default',
-  ) {
-    this.region = region
-  }
-
-  /**
-   * Initialize client with credentials
-   */
-  async init(): Promise<void> {
-    this.credentials = await resolveCredentials(this.profile)
-    if (this.credentials.region) {
-      this.region = this.credentials.region
-    }
-  }
-
-  /**
-   * Ensure credentials are loaded
-   */
-  private async ensureCredentials(): Promise<AWSCredentials> {
-    if (!this.credentials) {
-      await this.init()
-    }
-    return this.credentials!
-  }
-
-  /**
-   * Make a CloudFormation API request
-   */
-  private async request(action: string, params: Record<string, any>): Promise<any> {
-    const credentials = await this.ensureCredentials()
-
-    // Build query string
-    const queryParams: Record<string, string> = {
-      Action: action,
-      Version: '2010-05-15',
-      ...flattenParams(params),
-    }
-
-    const queryString = new URLSearchParams(queryParams).toString()
-
-    const response = await makeAWSRequest({
-      method: 'POST',
-      url: `https://cloudformation.${this.region}.amazonaws.com/`,
-      service: 'cloudformation',
-      region: this.region,
-      headers: {
-        'Content-Type': 'application/x-www-form-urlencoded',
-      },
-      body: queryString,
-      accessKeyId: credentials.accessKeyId,
-      secretAccessKey: credentials.secretAccessKey,
-      sessionToken: credentials.sessionToken,
-    })
-
-    return await parseXMLResponse(response)
-  }
-
-  /**
-   * Create a new CloudFormation stack
-   */
-  async createStack(options: CreateStackOptions): Promise<string> {
-    const params: Record<string, any> = {
-      StackName: options.stackName,
-    }
-
-    if (options.templateBody) {
-      params.TemplateBody = options.templateBody
-    }
-    else if (options.templateURL) {
-      params.TemplateURL = options.templateURL
-    }
-    else {
-      throw new Error('Either templateBody or templateURL must be provided')
-    }
-
-    if (options.parameters) {
-      params.Parameters = Object.entries(options.parameters).map(([key, value], index) => ({
-        [`Parameters.member.${index + 1}.ParameterKey`]: key,
-        [`Parameters.member.${index + 1}.ParameterValue`]: value,
-      }))
-    }
-
-    if (options.capabilities) {
-      params.Capabilities = options.capabilities.map((cap, index) => ({
-        [`Capabilities.member.${index + 1}`]: cap,
-      }))
-    }
-
-    if (options.tags) {
-      params.Tags = Object.entries(options.tags).map(([key, value], index) => ({
-        [`Tags.member.${index + 1}.Key`]: key,
-        [`Tags.member.${index + 1}.Value`]: value,
-      }))
-    }
-
-    if (options.timeoutInMinutes) {
-      params.TimeoutInMinutes = options.timeoutInMinutes
-    }
-
-    if (options.onFailure) {
-      params.OnFailure = options.onFailure
-    }
-
-    const result = await this.request('CreateStack', params)
-    return result.StackId
-  }
-
-  /**
-   * Update an existing CloudFormation stack
-   */
-  async updateStack(options: UpdateStackOptions): Promise<string> {
-    const params: Record<string, any> = {
-      StackName: options.stackName,
-    }
-
-    if (options.templateBody) {
-      params.TemplateBody = options.templateBody
-    }
-    else if (options.templateURL) {
-      params.TemplateURL = options.templateURL
-    }
-
-    if (options.parameters) {
-      params.Parameters = Object.entries(options.parameters).map(([key, value], index) => ({
-        [`Parameters.member.${index + 1}.ParameterKey`]: key,
-        [`Parameters.member.${index + 1}.ParameterValue`]: value,
-      }))
-    }
-
-    if (options.capabilities) {
-      params.Capabilities = options.capabilities.map((cap, index) => ({
-        [`Capabilities.member.${index + 1}`]: cap,
-      }))
-    }
-
-    if (options.tags) {
-      params.Tags = Object.entries(options.tags).map(([key, value], index) => ({
-        [`Tags.member.${index + 1}.Key`]: key,
-        [`Tags.member.${index + 1}.Value`]: value,
-      }))
-    }
-
-    const result = await this.request('UpdateStack', params)
-    return result.StackId
-  }
-
-  /**
-   * Delete a CloudFormation stack
-   */
-  async deleteStack(stackName: string): Promise<void> {
-    await this.request('DeleteStack', {
-      StackName: stackName,
-    })
-  }
-
-  /**
-   * Describe a CloudFormation stack
-   */
-  async describeStack(stackName: string): Promise<CloudFormationStack> {
-    const result = await this.request('DescribeStacks', {
-      StackName: stackName,
-    })
-
-    // Parse stack from XML response
-    return parseStack(result)
-  }
-
-  /**
-   * List all CloudFormation stacks
-   */
-  async listStacks(statusFilter?: string[]): Promise<CloudFormationStack[]> {
-    const params: Record<string, any> = {}
-
-    if (statusFilter) {
-      params.StackStatusFilter = statusFilter.map((status, index) => ({
-        [`StackStatusFilter.member.${index + 1}`]: status,
-      }))
-    }
-
-    const result = await this.request('ListStacks', params)
-    return parseStackList(result)
-  }
-
-  /**
-   * Get stack events
-   */
-  async describeStackEvents(stackName: string): Promise<StackEvent[]> {
-    const result = await this.request('DescribeStackEvents', {
-      StackName: stackName,
-    })
-
-    return parseStackEvents(result)
-  }
-
-  /**
-   * Wait for stack to reach a terminal state
-   */
-  async waitForStack(
-    stackName: string,
-    desiredStates: string[],
-    onProgress?: (event: StackEvent) => void,
-  ): Promise<CloudFormationStack> {
-    const pollInterval = 5000 // 5 seconds
-    const maxAttempts = 360 // 30 minutes maximum
-    let attempts = 0
-    let lastEventId: string | null = null
-
-    while (attempts < maxAttempts) {
-      attempts++
-
-      const stack = await this.describeStack(stackName)
-
-      // Get latest events
-      if (onProgress) {
-        const events = await this.describeStackEvents(stackName)
-        const newEvents = lastEventId
-          ? events.filter(e => e.EventId !== lastEventId).reverse()
-          : [events[0]]
-
-        newEvents.forEach(event => onProgress(event))
-
-        if (events.length > 0) {
-          lastEventId = events[0].EventId
-        }
-      }
-
-      // Check if stack reached desired state
-      if (stack.StackStatus && desiredStates.includes(stack.StackStatus)) {
-        return stack
-      }
-
-      // Check for failure states
-      if (stack.StackStatus?.includes('FAILED') || stack.StackStatus?.includes('ROLLBACK')) {
-        throw new Error(
-          `Stack reached failed state: ${stack.StackStatus}\n`
-          + `Reason: ${stack.StackStatusReason || 'Unknown'}`,
-        )
-      }
-
-      // Wait before next poll
-      await new Promise(resolve => setTimeout(resolve, pollInterval))
-    }
-
-    throw new Error(`Timeout waiting for stack ${stackName} to complete`)
-  }
-
-  /**
-   * Create a change set
-   */
-  async createChangeSet(options: {
-    stackName: string
-    changeSetName: string
-    templateBody?: string
-    templateURL?: string
-    parameters?: Record<string, string>
-    capabilities?: string[]
-  }): Promise<string> {
-    const params: Record<string, any> = {
-      StackName: options.stackName,
-      ChangeSetName: options.changeSetName,
-      ChangeSetType: 'UPDATE',
-    }
-
-    if (options.templateBody) {
-      params.TemplateBody = options.templateBody
-    }
-    else if (options.templateURL) {
-      params.TemplateURL = options.templateURL
-    }
-
-    if (options.parameters) {
-      params.Parameters = Object.entries(options.parameters).map(([key, value], index) => ({
-        [`Parameters.member.${index + 1}.ParameterKey`]: key,
-        [`Parameters.member.${index + 1}.ParameterValue`]: value,
-      }))
-    }
-
-    if (options.capabilities) {
-      params.Capabilities = options.capabilities.map((cap, index) => ({
-        [`Capabilities.member.${index + 1}`]: cap,
-      }))
-    }
-
-    const result = await this.request('CreateChangeSet', params)
-    return result.ChangeSetId
-  }
-
-  /**
-   * Execute a change set
-   */
-  async executeChangeSet(changeSetName: string, stackName: string): Promise<void> {
-    await this.request('ExecuteChangeSet', {
-      ChangeSetName: changeSetName,
-      StackName: stackName,
-    })
-  }
-}
-
-/**
- * Flatten nested parameters for AWS API query string
- */
-function flattenParams(params: Record<string, any>, prefix: string = ''): Record<string, string> {
-  const result: Record<string, string> = {}
-
-  for (const [key, value] of Object.entries(params)) {
-    const fullKey = prefix ? `${prefix}.${key}` : key
-
-    if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        if (typeof item === 'object') {
-          Object.assign(result, flattenParams(item, `${fullKey}.${index + 1}`))
-        }
-        else {
-          result[`${fullKey}.${index + 1}`] = String(item)
-        }
-      })
-    }
-    else if (typeof value === 'object' && value !== null) {
-      Object.assign(result, flattenParams(value, fullKey))
-    }
-    else if (value !== undefined && value !== null) {
-      result[fullKey] = String(value)
-    }
-  }
-
-  return result
-}
-
-/**
- * Parse stack from XML response
- */
-function parseStack(data: any): CloudFormationStack {
-  // Simplified parsing - in production, use a proper XML parser
-  return {
-    StackName: data.StackName || '',
-    StackId: data.StackId,
-    StackStatus: data.StackStatus,
-    CreationTime: data.CreationTime,
-    LastUpdatedTime: data.LastUpdatedTime,
-    StackStatusReason: data.StackStatusReason,
-    Description: data.Description,
-  }
-}
-
-/**
- * Parse stack list from XML response
- */
-function parseStackList(data: any): CloudFormationStack[] {
-  // Simplified parsing
-  return []
-}
-
-/**
- * Parse stack events from XML response
- */
-function parseStackEvents(data: any): StackEvent[] {
-  // Simplified parsing
-  return []
-}

package/src/aws/cloudfront.ts

@@ -1,158 +0,0 @@
-/**
- * AWS CloudFront API Client
- * Direct API calls for CloudFront invalidations without AWS SDK
- */
-
-import type { AWSCredentials } from './credentials'
-import { resolveCredentials } from './credentials'
-import { makeAWSRequest, parseXMLResponse } from './signature'
-
-export interface InvalidationOptions {
-  distributionId: string
-  paths: string[]
-  callerReference?: string
-}
-
-/**
- * CloudFront API Client
- */
-export class CloudFrontClient {
-  private credentials: AWSCredentials | null = null
-
-  constructor(
-    private readonly profile: string = 'default',
-  ) {}
-
-  /**
-   * Initialize client with credentials
-   */
-  async init(): Promise<void> {
-    this.credentials = await resolveCredentials(this.profile)
-  }
-
-  /**
-   * Ensure credentials are loaded
-   */
-  private async ensureCredentials(): Promise<AWSCredentials> {
-    if (!this.credentials) {
-      await this.init()
-    }
-    return this.credentials!
-  }
-
-  /**
-   * Create a cache invalidation
-   */
-  async createInvalidation(options: InvalidationOptions): Promise<string> {
-    const credentials = await this.ensureCredentials()
-
-    const callerReference = options.callerReference || `invalidation-${Date.now()}`
-
-    const body = `<?xml version="1.0" encoding="UTF-8"?>
-<InvalidationBatch>
-  <Paths>
-    <Quantity>${options.paths.length}</Quantity>
-    <Items>
-      ${options.paths.map(path => `<Path>${path}</Path>`).join('')}
-    </Items>
-  </Paths>
-  <CallerReference>${callerReference}</CallerReference>
-</InvalidationBatch>`
-
-    const url = `https://cloudfront.amazonaws.com/2020-05-31/distribution/${options.distributionId}/invalidation`
-
-    const response = await makeAWSRequest({
-      method: 'POST',
-      url,
-      service: 'cloudfront',
-      region: 'us-east-1', // CloudFront is global, but uses us-east-1
-      headers: {
-        'Content-Type': 'text/xml',
-      },
-      body,
-      accessKeyId: credentials.accessKeyId,
-      secretAccessKey: credentials.secretAccessKey,
-      sessionToken: credentials.sessionToken,
-    })
-
-    const data = await parseXMLResponse(response)
-    return data.Id
-  }
-
-  /**
-   * Get invalidation status
-   */
-  async getInvalidation(distributionId: string, invalidationId: string): Promise<any> {
-    const credentials = await this.ensureCredentials()
-
-    const url = `https://cloudfront.amazonaws.com/2020-05-31/distribution/${distributionId}/invalidation/${invalidationId}`
-
-    const response = await makeAWSRequest({
-      method: 'GET',
-      url,
-      service: 'cloudfront',
-      region: 'us-east-1',
-      accessKeyId: credentials.accessKeyId,
-      secretAccessKey: credentials.secretAccessKey,
-      sessionToken: credentials.sessionToken,
-    })
-
-    return await parseXMLResponse(response)
-  }
-
-  /**
-   * List invalidations for a distribution
-   */
-  async listInvalidations(distributionId: string): Promise<any[]> {
-    const credentials = await this.ensureCredentials()
-
-    const url = `https://cloudfront.amazonaws.com/2020-05-31/distribution/${distributionId}/invalidation`
-
-    const response = await makeAWSRequest({
-      method: 'GET',
-      url,
-      service: 'cloudfront',
-      region: 'us-east-1',
-      accessKeyId: credentials.accessKeyId,
-      secretAccessKey: credentials.secretAccessKey,
-      sessionToken: credentials.sessionToken,
-    })
-
-    const data = await parseXMLResponse(response)
-    return data.Items || []
-  }
-
-  /**
-   * Wait for invalidation to complete
-   */
-  async waitForInvalidation(
-    distributionId: string,
-    invalidationId: string,
-    maxAttempts: number = 60,
-    pollInterval: number = 5000,
-  ): Promise<void> {
-    for (let i = 0; i < maxAttempts; i++) {
-      const invalidation = await this.getInvalidation(distributionId, invalidationId)
-
-      if (invalidation.Status === 'Completed') {
-        return
-      }
-
-      if (i < maxAttempts - 1) {
-        await new Promise(resolve => setTimeout(resolve, pollInterval))
-      }
-    }
-
-    throw new Error(`Invalidation ${invalidationId} did not complete within the expected time`)
-  }
-
-  /**
-   * Invalidate all files in a distribution
-   */
-  async invalidateAll(distributionId: string): Promise<string> {
-    return await this.createInvalidation({
-      distributionId,
-      paths: ['/*'],
-    })
-  }
-}

package/src/aws/credentials.test.ts

@@ -1,132 +0,0 @@
-/**
- * AWS Credentials Provider Tests
- */
-
-import { describe, expect, it, beforeEach, afterEach } from 'bun:test'
-import {
-  fromEnvironment,
-  fromSharedCredentials,
-  createCredentialProvider,
-} from './credentials'
-
-describe('Credential Providers', () => {
-  // Store original env
-  const originalEnv = { ...process.env }
-
-  beforeEach(() => {
-    // Reset env before each test
-    process.env = { ...originalEnv }
-  })
-
-  afterEach(() => {
-    // Restore original env
-    process.env = originalEnv
-  })
-
-  describe('fromEnvironment', () => {
-    it('should return credentials from environment variables', () => {
-      process.env.AWS_ACCESS_KEY_ID = 'AKIATEST123'
-      process.env.AWS_SECRET_ACCESS_KEY = 'secret123'
-
-      const creds = fromEnvironment()
-
-      expect(creds).not.toBeNull()
-      expect(creds?.accessKeyId).toBe('AKIATEST123')
-      expect(creds?.secretAccessKey).toBe('secret123')
-      expect(creds?.sessionToken).toBeUndefined()
-    })
-
-    it('should include session token if present', () => {
-      process.env.AWS_ACCESS_KEY_ID = 'AKIATEST123'
-      process.env.AWS_SECRET_ACCESS_KEY = 'secret123'
-      process.env.AWS_SESSION_TOKEN = 'token123'
-
-      const creds = fromEnvironment()
-
-      expect(creds).not.toBeNull()
-      expect(creds?.sessionToken).toBe('token123')
-    })
-
-    it('should return null if access key is missing', () => {
-      process.env.AWS_SECRET_ACCESS_KEY = 'secret123'
-      delete process.env.AWS_ACCESS_KEY_ID
-
-      const creds = fromEnvironment()
-
-      expect(creds).toBeNull()
-    })
-
-    it('should return null if secret key is missing', () => {
-      process.env.AWS_ACCESS_KEY_ID = 'AKIATEST123'
-      delete process.env.AWS_SECRET_ACCESS_KEY
-
-      const creds = fromEnvironment()
-
-      expect(creds).toBeNull()
-    })
-  })
-
-  describe('fromSharedCredentials', () => {
-    it('should return null for non-existent file', () => {
-      const creds = fromSharedCredentials({
-        credentialsFile: '/nonexistent/path/credentials',
-      })
-
-      expect(creds).toBeNull()
-    })
-
-    it('should parse credentials from a valid file', () => {
-      // This test would need a mock file or temp file
-      // For now, just verify the function doesn't crash
-      const creds = fromSharedCredentials({
-        credentialsFile: '/tmp/test-aws-credentials-nonexistent',
-      })
-
-      expect(creds).toBeNull()
-    })
-  })
-
-  describe('createCredentialProvider', () => {
-    it('should create a provider function', () => {
-      const provider = createCredentialProvider()
-      expect(typeof provider).toBe('function')
-    })
-
-    it('should cache credentials', async () => {
-      process.env.AWS_ACCESS_KEY_ID = 'AKIATEST123'
-      process.env.AWS_SECRET_ACCESS_KEY = 'secret123'
-
-      const provider = createCredentialProvider()
-
-      const creds1 = await provider()
-      const creds2 = await provider()
-
-      expect(creds1).toEqual(creds2)
-      expect(creds1.accessKeyId).toBe('AKIATEST123')
-    })
-
-    it('should throw if no credentials found', async () => {
-      delete process.env.AWS_ACCESS_KEY_ID
-      delete process.env.AWS_SECRET_ACCESS_KEY
-      delete process.env.AWS_PROFILE
-
-      const provider = createCredentialProvider({
-        credentialsFile: '/nonexistent/path',
-      })
-
-      // This will try all providers and fail
-      // In real tests, you'd mock the metadata endpoints
-      await expect(provider()).rejects.toThrow('Could not find AWS credentials')
-    })
-  })
-})
-
-describe('Credential File Parsing', () => {
-  it('should handle empty credentials gracefully', () => {
-    delete process.env.AWS_ACCESS_KEY_ID
-    delete process.env.AWS_SECRET_ACCESS_KEY
-
-    const creds = fromEnvironment()
-    expect(creds).toBeNull()
-  })
-})