@stacksjs/ts-cloud-core 0.1.6 → 0.1.8

package/dist/aws/cloudformation.d.ts

@@ -0,0 +1,69 @@
+import type { AWSCredentials } from './credentials';
+export declare 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 declare 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 declare interface UpdateStackOptions {
+  stackName: string
+  templateBody?: string
+  templateURL?: string
+  parameters?: Record<string, string>
+  capabilities?: string[]
+  tags?: Record<string, string>
+}
+export declare interface StackEvent {
+  EventId: string
+  StackName: string
+  LogicalResourceId: string
+  PhysicalResourceId?: string
+  ResourceType: string
+  Timestamp: string
+  ResourceStatus: string
+  ResourceStatusReason?: string
+}
+/**
+ * CloudFormation API Client
+ */
+export declare class CloudFormationClient {
+  private credentials: AWSCredentials | null;
+  private region: string;
+  private readonly profile?: string;
+  constructor(region?: string, profile?: string);
+  init(): Promise<void>;
+  private ensureCredentials(): Promise<AWSCredentials>;
+  private request(action: string, params: Record<string, any>): Promise<any>;
+  createStack(options: CreateStackOptions): Promise<string>;
+  updateStack(options: UpdateStackOptions): Promise<string>;
+  deleteStack(stackName: string): Promise<void>;
+  describeStack(stackName: string): Promise<CloudFormationStack>;
+  listStacks(statusFilter?: string[]): Promise<CloudFormationStack[]>;
+  describeStackEvents(stackName: string): Promise<StackEvent[]>;
+  waitForStack(stackName: string, desiredStates: string[], onProgress?: (event: StackEvent) => void): Promise<CloudFormationStack>;
+  createChangeSet(options: {
+    stackName: string
+    changeSetName: string
+    templateBody?: string
+    templateURL?: string
+    parameters?: Record<string, string>
+    capabilities?: string[]
+  }): Promise<string>;
+  executeChangeSet(changeSetName: string, stackName: string): Promise<void>;
+}

package/dist/aws/cloudfront.d.ts

@@ -0,0 +1,21 @@
+import type { AWSCredentials } from './credentials';
+export declare interface InvalidationOptions {
+  distributionId: string
+  paths: string[]
+  callerReference?: string
+}
+/**
+ * CloudFront API Client
+ */
+export declare class CloudFrontClient {
+  private credentials: AWSCredentials | null;
+  private readonly profile?: string;
+  constructor(profile?: string);
+  init(): Promise<void>;
+  private ensureCredentials(): Promise<AWSCredentials>;
+  createInvalidation(options: InvalidationOptions): Promise<string>;
+  getInvalidation(distributionId: string, invalidationId: string): Promise<any>;
+  listInvalidations(distributionId: string): Promise<any[]>;
+  waitForInvalidation(distributionId: string, invalidationId: string, maxAttempts?: number, pollInterval?: number): Promise<void>;
+  invalidateAll(distributionId: string): Promise<string>;
+}

package/dist/aws/credentials.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Get credentials from environment variables
+ * Checks: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, AWS_SESSION_TOKEN
+ */
+export declare function fromEnvironment(): AWSCredentials | null;
+/**
+ * Get credentials from shared credentials file (~/.aws/credentials)
+ */
+export declare function fromSharedCredentials(options?: CredentialProviderOptions): AWSCredentials | null;
+/**
+ * Get credentials from EC2 instance metadata service (IMDSv2)
+ */
+export declare function fromEC2Metadata(options?: CredentialProviderOptions): Promise<AWSCredentials | null>;
+/**
+ * Get credentials from ECS task metadata
+ */
+export declare function fromECSMetadata(options?: CredentialProviderOptions): Promise<AWSCredentials | null>;
+/**
+ * Get credentials from web identity token (for Kubernetes/IRSA)
+ */
+export declare function fromWebIdentity(options?: CredentialProviderOptions): Promise<AWSCredentials | null>;
+/**
+ * Get credentials using the default credential chain
+ * Tries providers in order: Environment -> Shared Credentials -> Web Identity -> ECS -> EC2
+ */
+export declare function getCredentials(options?: CredentialProviderOptions): Promise<AWSCredentials>;
+/**
+ * Create a credential provider that caches and auto-refreshes credentials
+ */
+export declare function createCredentialProvider(options?: CredentialProviderOptions): () => Promise<AWSCredentials>;
+/**
+ * Resolve AWS credentials from various sources
+ * @deprecated Use getCredentials() instead
+ */
+export declare function resolveCredentials(profile?: string): Promise<AWSCredentials>;
+/**
+ * Resolve AWS region from environment or config
+ */
+export declare function resolveRegion(profile?: string): string;
+/**
+ * Get AWS account ID using STS GetCallerIdentity
+ */
+export declare function getAccountId(credentials?: AWSCredentials): Promise<string>;
+export declare interface AWSCredentials {
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  expiration?: Date
+  region?: string
+}
+export declare interface CredentialProviderOptions {
+  profile?: string
+  credentialsFile?: string
+  configFile?: string
+  timeout?: number
+}
+// ============================================================================
+// Backwards Compatibility Exports
+// ============================================================================
+export declare interface AWSProfile {
+  name: string
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  region?: string
+}

package/dist/aws/index.d.ts

@@ -0,0 +1,73 @@
+export type {
+  SignatureOptions,
+  SignedRequest,
+  PresignedUrlOptions,
+  RetryOptions,
+} from './signature';
+export type {
+  AWSCredentials,
+  AWSProfile,
+  CredentialProviderOptions,
+} from './credentials';
+export type {
+  CloudFormationStack,
+  CreateStackOptions,
+  UpdateStackOptions,
+  StackEvent,
+} from './cloudformation';
+export type {
+  S3ClientOptions,
+  GetObjectOptions,
+  PutObjectOptions,
+  ListObjectsOptions,
+  ListObjectsResult,
+  S3Object,
+  HeadObjectResult,
+  CopyObjectOptions,
+  MultipartUploadOptions,
+  MultipartProgress,
+} from './s3';
+export type {
+  InvalidationOptions,
+} from './cloudfront';
+export {
+  signRequest,
+  signRequestAsync,
+  makeAWSRequest,
+  makeAWSRequestAsync,
+  makeAWSRequestOnce,
+  createPresignedUrl,
+  createPresignedUrlAsync,
+  detectServiceRegion,
+  clearSigningKeyCache,
+  getSigningKeyCacheSize,
+  parseXMLResponse,
+  parseJSONResponse,
+  isNodeCryptoAvailable,
+  isWebCryptoAvailable,
+} from './signature';
+export {
+  // New credential providers
+  fromEnvironment,
+  fromSharedCredentials,
+  fromEC2Metadata,
+  fromECSMetadata,
+  fromWebIdentity,
+  getCredentials,
+  createCredentialProvider,
+  // Backwards compatibility
+  resolveCredentials,
+  resolveRegion,
+  getAccountId,
+} from './credentials';
+export {
+  CloudFormationClient,
+} from './cloudformation';
+export {
+  S3Client,
+  S3Error,
+  createS3Client,
+} from './s3';
+export {
+  CloudFrontClient,
+} from './cloudfront';

package/dist/aws/s3.d.ts

@@ -0,0 +1,130 @@
+import { getCredentials } from './credentials';
+/**
+ * Convenience function to create an S3 client
+ */
+export declare function createS3Client(options?: S3ClientOptions): S3Client;
+export declare interface S3ClientOptions {
+  region?: string
+  endpoint?: string
+  forcePathStyle?: boolean
+  credentials?: AWSCredentials
+  credentialOptions?: CredentialProviderOptions
+  retryOptions?: RetryOptions
+}
+export declare interface GetObjectOptions {
+  range?: string
+  ifModifiedSince?: Date
+  ifMatch?: string
+  ifNoneMatch?: string
+  responseContentType?: string
+  responseContentDisposition?: string
+}
+export declare interface PutObjectOptions {
+  contentType?: string
+  contentEncoding?: string
+  cacheControl?: string
+  contentDisposition?: string
+  metadata?: Record<string, string>
+  storageClass?: string
+  serverSideEncryption?: string
+  acl?: string
+  tagging?: string
+}
+export declare interface ListObjectsOptions {
+  prefix?: string
+  delimiter?: string
+  maxKeys?: number
+  continuationToken?: string
+  startAfter?: string
+}
+export declare interface ListObjectsResult {
+  contents: S3Object[]
+  commonPrefixes: string[]
+  isTruncated: boolean
+  continuationToken?: string
+  nextContinuationToken?: string
+  keyCount: number
+  maxKeys: number
+  prefix?: string
+  delimiter?: string
+}
+export declare interface S3Object {
+  key: string
+  lastModified: Date
+  etag: string
+  size: number
+  storageClass: string
+}
+export declare interface HeadObjectResult {
+  contentLength: number
+  contentType: string
+  etag: string
+  lastModified: Date
+  metadata: Record<string, string>
+  storageClass?: string
+  serverSideEncryption?: string
+}
+export declare interface CopyObjectOptions {
+  metadataDirective?: 'COPY' | 'REPLACE'
+  metadata?: Record<string, string>
+  contentType?: string
+  storageClass?: string
+  acl?: string
+}
+export declare interface MultipartUploadOptions extends PutObjectOptions {
+  partSize?: number
+  concurrency?: number
+  onProgress?: (progress: MultipartProgress) => void
+}
+export declare interface MultipartProgress {
+  loaded: number
+  total: number
+  part: number
+  totalParts: number
+}
+export declare interface PresignedUrlOptions {
+  expiresIn?: number
+  method?: string
+}
+/**
+ * S3 Client for high-level S3 operations
+ */
+export declare class S3Client {
+  private region: string;
+  private endpoint: string;
+  private forcePathStyle: boolean;
+  private credentials?: AWSCredentials;
+  private credentialOptions?: CredentialProviderOptions;
+  private retryOptions: RetryOptions;
+  constructor(options?: S3ClientOptions);
+  private getCredentials(): Promise<AWSCredentials>;
+  private buildUrl(bucket: string, key?: string): string;
+  get(bucket: string, key: string, options?: GetObjectOptions): Promise<Response>;
+  getText(bucket: string, key: string, options?: GetObjectOptions): Promise<string>;
+  getJSON<T = unknown>(bucket: string, key: string, options?: GetObjectOptions): Promise<T>;
+  getBuffer(bucket: string, key: string, options?: GetObjectOptions): Promise<ArrayBuffer>;
+  put(bucket: string, key: string, body: string | ArrayBuffer | Uint8Array | Blob | ReadableStream, options?: PutObjectOptions): Promise<{ etag: string }>;
+  private putSimple(bucket: string, key: string, body: string | ArrayBuffer | Uint8Array | Blob, size: number, options: PutObjectOptions): Promise<{ etag: string }>;
+  delete(bucket: string, key: string): Promise<void>;
+  deleteMany(bucket: string, keys: string[]): Promise<{ deleted: string[], errors: Array<{ key: string, error: string }> }>;
+  list(bucket: string, options?: ListObjectsOptions): Promise<ListObjectsResult>;
+  listAll(bucket: string, options?: Omit<ListObjectsOptions, 'continuationToken'>): AsyncGenerator<S3Object>;
+  head(bucket: string, key: string): Promise<HeadObjectResult | null>;
+  exists(bucket: string, key: string): Promise<boolean>;
+  copy(sourceBucket: string, sourceKey: string, destBucket: string, destKey: string, options?: CopyObjectOptions): Promise<{ etag: string }>;
+  getPresignedUrl(bucket: string, key: string, options?: PresignedUrlOptions): Promise<string>;
+  uploadMultipart(bucket: string, key: string, body: ReadableStream | Blob | ArrayBuffer | Uint8Array, options?: MultipartUploadOptions): Promise<{ etag: string }>;
+  private initiateMultipartUpload(bucket: string, key: string, options: PutObjectOptions): Promise<string>;
+  private uploadParts(bucket: string, key: string, uploadId: string, stream: ReadableStream<Uint8Array>, partSize: number, credentials: AWSCredentials, totalSize: number | undefined, concurrency: number, onProgress?: (progress: MultipartProgress) => void): Promise<Array<{ partNumber: number, etag: string }>>;
+  private completeMultipartUpload(bucket: string, key: string, uploadId: string, parts: Array<{ partNumber: number, etag: string }>): Promise<{ etag: string }>;
+  abortMultipartUpload(bucket: string, key: string, uploadId: string): Promise<void>;
+}
+/**
+ * S3 Error class
+ */
+export declare class S3Error extends Error {
+  public statusCode: number;
+  public bucket: string;
+  public key?: string;
+  constructor(message: string, statusCode: number, bucket: string, key?: string);
+}

package/dist/aws/signature.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Detect service and region from AWS URL
+ * Supports standard AWS endpoints, Lambda URLs, R2, and Backblaze B2
+ */
+export declare function detectServiceRegion(url: string | URL): { service: string, region: string };
+/**
+ * Sign an AWS request using Signature Version 4
+ */
+export declare function signRequest(options: SignatureOptions): SignedRequest;
+/**
+ * Sign an AWS request using Signature Version 4 (async - browser compatible)
+ * Use this in browser environments where crypto.subtle is available
+ */
+export declare function signRequestAsync(options: SignatureOptions): Promise<SignedRequest>;
+/**
+ * Generate a presigned URL for AWS requests (e.g., S3 GetObject, PutObject)
+ */
+export declare function createPresignedUrl(options: PresignedUrlOptions): string;
+/**
+ * Generate a presigned URL for AWS requests (async - browser compatible)
+ */
+export declare function createPresignedUrlAsync(options: PresignedUrlOptions): Promise<string>;
+/**
+ * Make a signed AWS API request with automatic retry
+ */
+export declare function makeAWSRequest(options: SignatureOptions, retryOptions?: RetryOptions): Promise<Response>;
+/**
+ * Make a signed AWS API request without retry (for backwards compatibility)
+ */
+export declare function makeAWSRequestOnce(options: SignatureOptions): Promise<Response>;
+/**
+ * Make a signed AWS API request with automatic retry (async - browser compatible)
+ * Use this in browser environments where crypto.subtle is available
+ */
+export declare function makeAWSRequestAsync(options: SignatureOptions, retryOptions?: RetryOptions): Promise<Response>;
+/**
+ * Parse XML response from AWS
+ */
+export declare function parseXMLResponse<T = any>(response: Response): Promise<T>;
+/**
+ * Parse JSON response from AWS
+ */
+export declare function parseJSONResponse<T = any>(response: Response): Promise<T>;
+/**
+ * Clear the internal signing key cache
+ * Call this when credentials change or for testing
+ */
+export declare function clearSigningKeyCache(): void;
+/**
+ * Get current cache size (for diagnostics)
+ */
+export declare function getSigningKeyCacheSize(): number;
+/**
+ * Check if Node.js crypto is available (for sync operations)
+ * Returns true in Node.js/Bun, false in browser
+ */
+export declare function isNodeCryptoAvailable(): boolean;
+/**
+ * Check if Web Crypto API is available (for async operations)
+ * Returns true in modern browsers and Node.js 15+
+ */
+export declare function isWebCryptoAvailable(): boolean;
+export declare interface SignatureOptions {
+  method: string
+  url: string
+  service?: string
+  region?: string
+  headers?: Record<string, string>
+  body?: string
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  cache?: Map<string, Buffer | Uint8Array>
+  signQuery?: boolean
+  expiresIn?: number
+  datetime?: string
+}
+export declare interface SignedRequest {
+  url: string
+  method: string
+  headers: Record<string, string>
+  body?: string
+}
+export declare interface PresignedUrlOptions {
+  url: string
+  method?: string
+  accessKeyId: string
+  secretAccessKey: string
+  sessionToken?: string
+  service?: string
+  region?: string
+  expiresIn?: number
+  cache?: Map<string, Buffer | Uint8Array>
+}
+export declare interface RetryOptions {
+  maxRetries?: number
+  initialDelayMs?: number
+  maxDelayMs?: number
+  retryableStatusCodes?: number[]
+  timeoutMs?: number
+}

package/dist/backup/disaster-recovery.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Global disaster recovery manager instance
+ */
+export declare const drManager: DisasterRecoveryManager;
+/**
+ * Disaster Recovery Module
+ * Automated failover, recovery runbooks, and DR testing
+ */
+export declare interface DisasterRecoveryPlan {
+  id: string
+  name: string
+  primaryRegion: string
+  secondaryRegion: string
+  rto: number
+  rpo: number
+  resources: DRResource[]
+  runbook: RecoveryRunbook
+  testSchedule?: string
+}
+export declare interface DRResource {
+  resourceId: string
+  resourceType: 'rds' | 'dynamodb' | 'efs' | 's3' | 'ec2' | 'ecs'
+  primaryArn: string
+  secondaryArn?: string
+  replicationEnabled: boolean
+}
+export declare interface RecoveryRunbook {
+  steps: RecoveryStep[]
+  estimatedDuration: number
+  requiredApprovals?: string[]
+}
+export declare interface RecoveryStep {
+  order: number
+  name: string
+  description: string
+  action: string
+  automatable: boolean
+  estimatedDuration: number
+  rollbackable: boolean
+}
+export declare interface FailoverTest {
+  id: string
+  planId: string
+  status: 'scheduled' | 'running' | 'completed' | 'failed'
+  startTime: Date
+  endTime?: Date
+  results?: FailoverTestResult[]
+}
+export declare interface FailoverTestResult {
+  step: string
+  status: 'success' | 'failed' | 'skipped'
+  duration: number
+  message?: string
+}
+/**
+ * Disaster recovery manager
+ */
+export declare class DisasterRecoveryManager {
+  private drPlans: Map<string, DisasterRecoveryPlan>;
+  private failoverTests: Map<string, FailoverTest>;
+  private planCounter: any;
+  private testCounter: any;
+  createDRPlan(plan: Omit<DisasterRecoveryPlan, 'id'>): DisasterRecoveryPlan;
+  createRDSDRPlan(options: {
+    primaryDbArn: string
+    secondaryDbArn: string
+    primaryRegion: string
+    secondaryRegion: string
+    rto?: number
+    rpo?: number
+  }): DisasterRecoveryPlan;
+  createDynamoDBDRPlan(options: {
+    tableArn: string
+    regions: string[]
+    rto?: number
+    rpo?: number
+  }): DisasterRecoveryPlan;
+  private generateRDSRunbook(primaryRegion: string, secondaryRegion: string): RecoveryRunbook;
+  private generateDynamoDBRunbook(regions: string[]): RecoveryRunbook;
+  executeFailover(planId: string, dryRun?: boolean): Promise<{
+    success: boolean
+    duration: number
+    completedSteps: number
+    failedStep?: string
+  }>;
+  scheduleFailoverTest(planId: string, testDate: Date): FailoverTest;
+  runFailoverTest(planId: string): Promise<FailoverTest>;
+  getDRPlan(id: string): DisasterRecoveryPlan | undefined;
+  listDRPlans(): DisasterRecoveryPlan[];
+  getFailoverTest(id: string): FailoverTest | undefined;
+  listFailoverTests(): FailoverTest[];
+  validateDRPlan(plan: DisasterRecoveryPlan): {
+    valid: boolean
+    warnings: string[]
+    errors: string[]
+  };
+  clear(): void;
+}

package/dist/backup/index.d.ts

@@ -0,0 +1,24 @@
+export type {
+  BackupPlan,
+  BackupResource,
+  BackupLifecycle,
+  BackupVault,
+  RestoreJob,
+  ContinuousBackup,
+} from './manager';
+export type {
+  DisasterRecoveryPlan,
+  DRResource,
+  RecoveryRunbook,
+  RecoveryStep,
+  FailoverTest,
+  FailoverTestResult,
+} from './disaster-recovery';
+export {
+  BackupManager,
+  backupManager,
+} from './manager';
+export {
+  DisasterRecoveryManager,
+  drManager,
+} from './disaster-recovery';