@ts-cloud/core 0.2.2 → 0.2.4

package/dist/utils/cache.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Caching utilities for performance optimization
+ * Caches CloudFormation templates, credentials, and other data
+ */
+export interface CacheOptions {
+    ttl?: number;
+    maxSize?: number;
+}
+export interface CacheEntry<T> {
+    value: T;
+    timestamp: number;
+    hash?: string;
+}
+/**
+ * Simple in-memory cache with TTL support
+ */
+export declare class Cache<T = any> {
+    private cache;
+    private ttl;
+    private maxSize;
+    constructor(options?: CacheOptions);
+    /**
+     * Get value from cache
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: T, hash?: string): void;
+    /**
+     * Check if cache has key and it's not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Clear cache
+     */
+    clear(): void;
+    /**
+     * Remove expired entries
+     */
+    prune(): void;
+    /**
+     * Get cache stats
+     */
+    stats(): {
+        size: number;
+        ttl: number;
+        maxSize: number;
+    };
+}
+/**
+ * File-based cache for persistent caching
+ */
+export declare class FileCache<T = any> {
+    private cacheDir;
+    private ttl;
+    constructor(cacheDir: string, options?: CacheOptions);
+    /**
+     * Get cache file path for key
+     */
+    private getCachePath;
+    /**
+     * Get value from cache
+     */
+    get(key: string): T | undefined;
+    /**
+     * Set value in cache
+     */
+    set(key: string, value: T, hash?: string): void;
+    /**
+     * Check if cache has key and it's not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Clear all cache files
+     */
+    clear(): void;
+    /**
+     * Remove expired entries
+     */
+    prune(): void;
+}
+/**
+ * Template cache for CloudFormation templates
+ */
+export declare class TemplateCache {
+    private cache;
+    constructor(cacheDir?: string);
+    /**
+     * Get template from cache
+     */
+    getTemplate(stackName: string): string | undefined;
+    /**
+     * Save template to cache
+     */
+    setTemplate(stackName: string, template: string): void;
+    /**
+     * Check if template has changed
+     */
+    hasChanged(stackName: string, newTemplate: string): boolean;
+    /**
+     * Hash template for comparison
+     */
+    private hashTemplate;
+    /**
+     * Clear all templates
+     */
+    clear(): void;
+    /**
+     * Prune expired templates
+     */
+    prune(): void;
+}
+/**
+ * Global template cache instance
+ */
+export declare const templateCache: TemplateCache;

package/dist/utils/diff.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Template diff utilities for incremental deployments
+ * Detect changes between CloudFormation templates to optimize deployments
+ */
+import type { CloudFormationTemplate } from '../cloudformation/types';
+export interface TemplateDiff {
+    added: string[];
+    modified: string[];
+    deleted: string[];
+    unchanged: string[];
+    parametersChanged: boolean;
+    outputsChanged: boolean;
+    hasChanges: boolean;
+}
+/**
+ * Compare two CloudFormation templates
+ */
+export declare function diffTemplates(oldTemplate: CloudFormationTemplate, newTemplate: CloudFormationTemplate): TemplateDiff;
+/**
+ * Get diff summary string
+ */
+export declare function getDiffSummary(diff: TemplateDiff): string;
+/**
+ * Check if diff requires replacement (destructive changes)
+ */
+export declare function requiresReplacement(diff: TemplateDiff, oldTemplate: CloudFormationTemplate, newTemplate: CloudFormationTemplate): boolean;
+/**
+ * Categorize changes by risk level
+ */
+export declare function categorizeChanges(diff: TemplateDiff): {
+    safe: string[];
+    caution: string[];
+    dangerous: string[];
+};
+/**
+ * Get deployment strategy based on diff
+ */
+export declare function getDeploymentStrategy(diff: TemplateDiff): {
+    strategy: 'create' | 'update' | 'replace' | 'skip';
+    reason: string;
+};
+/**
+ * Calculate diff statistics
+ */
+export declare function getDiffStats(diff: TemplateDiff): {
+    total: number;
+    added: number;
+    modified: number;
+    deleted: number;
+    unchanged: number;
+    changePercentage: number;
+};

package/dist/utils/hash.d.ts

@@ -0,0 +1,73 @@
+/**
+ * File hashing utilities for deployment optimization
+ * Fast hashing for detecting changed files
+ */
+export interface FileHash {
+    path: string;
+    hash: string;
+    size: number;
+    mtime: number;
+}
+export interface HashOptions {
+    algorithm?: 'md5' | 'sha1' | 'sha256';
+    chunkSize?: number;
+    ignorePatterns?: string[];
+}
+/**
+ * Hash a file using streaming for large files
+ */
+export declare function hashFile(filePath: string, options?: HashOptions): Promise<string>;
+/**
+ * Hash a string
+ */
+export declare function hashString(content: string, algorithm?: 'md5' | 'sha1' | 'sha256'): string;
+/**
+ * Hash a buffer
+ */
+export declare function hashBuffer(buffer: Buffer, algorithm?: 'md5' | 'sha1' | 'sha256'): string;
+/**
+ * Hash all files in a directory
+ */
+export declare function hashDirectory(dirPath: string, options?: HashOptions): Promise<FileHash[]>;
+/**
+ * Create a manifest hash from multiple file hashes
+ * Useful for detecting if any file in a directory has changed
+ */
+export declare function hashManifest(fileHashes: FileHash[]): string;
+/**
+ * Fast hash using file metadata (size + mtime)
+ * Much faster than content hash, but less reliable
+ * Use for quick change detection
+ */
+export declare function quickHash(filePath: string): string;
+/**
+ * Compare two sets of file hashes to find changes
+ */
+export declare function findChangedFiles(oldHashes: FileHash[], newHashes: FileHash[]): {
+    added: FileHash[];
+    modified: FileHash[];
+    deleted: FileHash[];
+};
+/**
+ * Cache for file hashes
+ */
+export declare class HashCache {
+    private cache;
+    constructor();
+    /**
+     * Get cached hash if file hasn't changed
+     */
+    get(filePath: string): string | undefined;
+    /**
+     * Cache a file hash
+     */
+    set(filePath: string, hash: string): void;
+    /**
+     * Get or compute hash
+     */
+    getOrCompute(filePath: string, options?: HashOptions): Promise<string>;
+    /**
+     * Clear cache
+     */
+    clear(): void;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utility functions for performance optimization
+ */
+export * from './cache';
+export * from './hash';
+export * from './parallel';
+export * from './diff';

package/dist/utils/parallel.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Parallel execution utilities
+ * Optimize deployment performance with parallel operations
+ */
+export interface ParallelOptions {
+    concurrency?: number;
+    stopOnError?: boolean;
+}
+export interface ParallelResult<T> {
+    results: T[];
+    errors: Error[];
+    duration: number;
+}
+/**
+ * Execute tasks in parallel with configurable concurrency
+ */
+export declare function parallel<T>(tasks: (() => Promise<T>)[], options?: ParallelOptions): Promise<ParallelResult<T>>;
+/**
+ * Execute tasks in batches with controlled concurrency
+ */
+export declare function batch<T, R>(items: T[], processor: (item: T) => Promise<R>, options?: ParallelOptions): Promise<ParallelResult<R>>;
+/**
+ * Map over array with parallel execution
+ */
+export declare function parallelMap<T, R>(items: T[], mapper: (item: T, index: number) => Promise<R>, concurrency?: number): Promise<R[]>;
+/**
+ * Execute tasks with retry logic
+ */
+export declare function parallelWithRetry<T>(tasks: (() => Promise<T>)[], options?: ParallelOptions & {
+    retries?: number;
+    retryDelay?: number;
+}): Promise<ParallelResult<T>>;
+/**
+ * Execute tasks in sequence (one after another)
+ */
+export declare function sequence<T>(tasks: (() => Promise<T>)[]): Promise<T[]>;
+/**
+ * Execute tasks with timeout
+ */
+export declare function withTimeout<T>(task: () => Promise<T>, timeoutMs: number, timeoutMessage?: string): Promise<T>;
+/**
+ * Rate limiter for API calls
+ */
+export declare class RateLimiter {
+    private maxConcurrent;
+    private minInterval;
+    private queue;
+    private running;
+    private lastExecution;
+    constructor(maxConcurrent?: number, minInterval?: number);
+    /**
+     * Execute task with rate limiting
+     */
+    execute<T>(task: () => Promise<T>): Promise<T>;
+    /**
+     * Wait for available execution slot
+     */
+    private waitForSlot;
+    /**
+     * Process queued tasks
+     */
+    private processQueue;
+    /**
+     * Get stats
+     */
+    stats(): {
+        running: number;
+        queued: number;
+    };
+}
+/**
+ * Chunk array into smaller batches
+ */
+export declare function chunk<T>(array: T[], size: number): T[][];
+/**
+ * Process array in chunks with parallel execution
+ */
+export declare function processInChunks<T, R>(items: T[], chunkSize: number, processor: (chunk: T[]) => Promise<R[]>): Promise<R[]>;

package/dist/validators/credentials.d.ts

@@ -0,0 +1,30 @@
+/**
+ * AWS Credentials Validation
+ * Validate credentials before deployment
+ */
+import type { AWSCredentials } from '../aws/credentials';
+export interface CredentialValidationResult {
+    valid: boolean;
+    accountId?: string;
+    region?: string;
+    error?: string;
+}
+/**
+ * Validate AWS credentials
+ */
+export declare function validateCredentials(profile?: string): Promise<CredentialValidationResult>;
+/**
+ * Check IAM permissions
+ */
+export declare function checkIAMPermissions(_credentials: AWSCredentials, requiredActions: string[]): Promise<{
+    allowed: string[];
+    denied: string[];
+}>;
+/**
+ * Get required IAM permissions for deployment
+ */
+export declare function getRequiredPermissions(config: any): string[];
+/**
+ * Suggest IAM policy for deployment
+ */
+export declare function suggestIAMPolicy(config: any): string;

package/dist/validators/credentials.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Credential Validation Tests
+ */
+export {};

package/dist/validators/quotas.d.ts

@@ -0,0 +1,64 @@
+/**
+ * AWS Service Quota Checking
+ * Check if deployment will exceed service limits
+ */
+export interface ServiceQuota {
+    service: string;
+    quotaName: string;
+    currentValue: number;
+    limit: number;
+    percentage: number;
+    warning: boolean;
+}
+/**
+ * Common AWS service limits by region
+ */
+export declare const DEFAULT_SERVICE_LIMITS: {
+    ec2: {
+        'Running On-Demand Instances': number;
+        'Elastic IPs': number;
+        VPCs: number;
+        'Internet Gateways': number;
+        'NAT Gateways': number;
+        'Security Groups': number;
+    };
+    rds: {
+        'DB Instances': number;
+        'DB Snapshots': number;
+        'DB Parameter Groups': number;
+    };
+    lambda: {
+        'Concurrent Executions': number;
+        'Function Storage': number;
+    };
+    s3: {
+        Buckets: number;
+    };
+    cloudformation: {
+        Stacks: number;
+        StackSets: number;
+    };
+    elasticache: {
+        Nodes: number;
+        Clusters: number;
+    };
+    dynamodb: {
+        Tables: number;
+    };
+    ecs: {
+        Clusters: number;
+        'Services per Cluster': number;
+    };
+};
+/**
+ * Check service quotas for deployment
+ */
+export declare function checkServiceQuotas(config: any): Promise<ServiceQuota[]>;
+/**
+ * Get quota usage summary
+ */
+export declare function getQuotaUsageSummary(quotas: ServiceQuota[]): string;
+/**
+ * Suggest quota increase if needed
+ */
+export declare function suggestQuotaIncrease(quotas: ServiceQuota[]): string[];

package/dist/validators/quotas.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Service Quota Validation Tests
+ */
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ts-cloud/core",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "description": "Core CloudFormation generation library for ts-cloud",
   "author": "Chris Breuer <chris@stacksjs.com>",
@@ -31,7 +31,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@ts-cloud/aws-types": "0.2.2"
+    "@ts-cloud/aws-types": "0.2.4"
   },
   "devDependencies": {
     "typescript": "^5.9.3"