@stacksjs/ts-cloud-core 0.1.8 → 0.1.9

package/src/aws/cloudformation.ts

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

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

@@ -0,0 +1,132 @@
+/**
+ * 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()
+  })
+})