@stacksjs/ts-cloud-core 0.1.6 → 0.1.8

package/dist/utils/diff.d.ts

@@ -0,0 +1,48 @@
+import type { CloudFormationTemplate } from '../cloudformation/types';
+/**
+ * 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
+};
+export declare interface TemplateDiff {
+  added: string[]
+  modified: string[]
+  deleted: string[]
+  unchanged: string[]
+  parametersChanged: boolean
+  outputsChanged: boolean
+  hasChanges: boolean
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1,58 @@
+import path from 'node:path';
+/**
+ * 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[]
+  };
+export declare interface FileHash {
+  path: string
+  hash: string
+  size: number
+  mtime: number
+}
+export declare interface HashOptions {
+  algorithm?: 'md5' | 'sha1' | 'sha256'
+  chunkSize?: number
+  ignorePatterns?: string[]
+}
+/**
+ * Cache for file hashes
+ */
+export declare class HashCache {
+  private cache: Map<string, { hash: string, mtime: number, size: number }>;
+  constructor();
+  get(filePath: string): string | undefined;
+  set(filePath: string, hash: string): void;
+  getOrCompute(filePath: string, options?: HashOptions): Promise<string>;
+  clear(): void;
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './cache';
+export * from './hash';
+export * from './parallel';
+export * from './diff';

package/dist/utils/parallel.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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>;
+/**
+ * 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[]>;
+/**
+ * Parallel execution utilities
+ * Optimize deployment performance with parallel operations
+ */
+export declare interface ParallelOptions {
+  concurrency?: number
+  stopOnError?: boolean
+}
+export declare interface ParallelResult<T> {
+  results: T[]
+  errors: Error[]
+  duration: number
+}
+/**
+ * Rate limiter for API calls
+ */
+export declare class RateLimiter {
+  private queue: (() => void)[];
+  private running: any;
+  private lastExecution: any;
+  private maxConcurrent?: number;
+  private minInterval?: number;
+  constructor(maxConcurrent?: number, minInterval?: number);
+  execute<T>(task: () => Promise<T>): Promise<T>;
+  private waitForSlot(): Promise<void>;
+  private processQueue(): void;
+  stats(): { running: number, queued: number };
+}

package/dist/validators/credentials.d.ts

@@ -0,0 +1,23 @@
+import type { AWSCredentials } from '../aws/credentials';
+/**
+ * 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;
+export declare interface CredentialValidationResult {
+  valid: boolean
+  accountId?: string
+  region?: string
+  error?: string
+}

package/dist/validators/quotas.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 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[];
+/**
+ * Common AWS service limits by region
+ */
+export declare const DEFAULT_SERVICE_LIMITS: {
+  ec2: {
+  'Running On-Demand Instances': 20;
+  'Elastic IPs': 5;
+  'VPCs': 5;
+  'Internet Gateways': 5;
+  'NAT Gateways': 5;
+  'Security Groups': 500
+};
+  rds: {
+  'DB Instances': 40;
+  'DB Snapshots': 100;
+  'DB Parameter Groups': 50
+};
+  lambda: {
+  'Concurrent Executions': 1000;
+  'Function Storage': unknown
+};
+  s3: {
+  'Buckets': 100
+};
+  cloudformation: {
+  'Stacks': 200;
+  'StackSets': 100
+};
+  elasticache: {
+  'Nodes': 100;
+  'Clusters': 100
+};
+  dynamodb: {
+  'Tables': 256
+};
+  ecs: {
+  'Clusters': 10000;
+  'Services per Cluster': 2000
+}
+};
+export declare interface ServiceQuota {
+  service: string
+  quotaName: string
+  currentValue: number
+  limit: number
+  percentage: number
+  warning: boolean
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stacksjs/ts-cloud-core",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Core CloudFormation generation library for ts-cloud",
   "author": "Chris Breuer <chris@stacksjs.com>",
@@ -26,13 +26,13 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target bun",
+    "build": "bun --bun build.ts",
     "prepublishOnly": "bun --bun run build",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@stacksjs/ts-cloud-types": "0.1.6",
-    "@stacksjs/ts-cloud-aws-types": "0.1.6"
+    "@stacksjs/ts-cloud-types": "0.1.8",
+    "@stacksjs/ts-cloud-aws-types": "0.1.8"
   },
   "devDependencies": {
     "typescript": "^5.9.3"