@stacksjs/ts-cloud-core 0.1.1

package/src/utils/hash.ts

@@ -0,0 +1,227 @@
+/**
+ * File hashing utilities for deployment optimization
+ * Fast hashing for detecting changed files
+ */
+
+import { createHash } from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+
+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 async function hashFile(
+  filePath: string,
+  options: HashOptions = {},
+): Promise<string> {
+  const algorithm = options.algorithm || 'sha256'
+  const chunkSize = options.chunkSize || 64 * 1024 // 64KB chunks
+
+  return new Promise((resolve, reject) => {
+    const hash = createHash(algorithm)
+    const stream = fs.createReadStream(filePath, { highWaterMark: chunkSize })
+
+    stream.on('data', chunk => hash.update(chunk))
+    stream.on('end', () => resolve(hash.digest('hex')))
+    stream.on('error', reject)
+  })
+}
+
+/**
+ * Hash a string
+ */
+export function hashString(content: string, algorithm: 'md5' | 'sha1' | 'sha256' = 'sha256'): string {
+  return createHash(algorithm).update(content).digest('hex')
+}
+
+/**
+ * Hash a buffer
+ */
+export function hashBuffer(buffer: Buffer, algorithm: 'md5' | 'sha1' | 'sha256' = 'sha256'): string {
+  return createHash(algorithm).update(buffer).digest('hex')
+}
+
+/**
+ * Hash all files in a directory
+ */
+export async function hashDirectory(
+  dirPath: string,
+  options: HashOptions = {},
+): Promise<FileHash[]> {
+  const ignorePatterns = options.ignorePatterns || [
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.ts-cloud',
+  ]
+
+  const files: FileHash[] = []
+
+  async function walk(dir: string): Promise<void> {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+      const relativePath = path.relative(dirPath, fullPath)
+
+      // Skip ignored patterns
+      if (ignorePatterns.some(pattern => relativePath.includes(pattern))) {
+        continue
+      }
+
+      if (entry.isDirectory()) {
+        await walk(fullPath)
+      }
+      else if (entry.isFile()) {
+        const stats = fs.statSync(fullPath)
+        const hash = await hashFile(fullPath, options)
+
+        files.push({
+          path: relativePath,
+          hash,
+          size: stats.size,
+          mtime: stats.mtimeMs,
+        })
+      }
+    }
+  }
+
+  await walk(dirPath)
+
+  return files
+}
+
+/**
+ * Create a manifest hash from multiple file hashes
+ * Useful for detecting if any file in a directory has changed
+ */
+export function hashManifest(fileHashes: FileHash[]): string {
+  const sorted = [...fileHashes].sort((a, b) => a.path.localeCompare(b.path))
+  const content = sorted.map(f => `${f.path}:${f.hash}`).join('\n')
+  return hashString(content)
+}
+
+/**
+ * Fast hash using file metadata (size + mtime)
+ * Much faster than content hash, but less reliable
+ * Use for quick change detection
+ */
+export function quickHash(filePath: string): string {
+  const stats = fs.statSync(filePath)
+  return hashString(`${filePath}:${stats.size}:${stats.mtimeMs}`)
+}
+
+/**
+ * Compare two sets of file hashes to find changes
+ */
+export function findChangedFiles(
+  oldHashes: FileHash[],
+  newHashes: FileHash[],
+): {
+    added: FileHash[]
+    modified: FileHash[]
+    deleted: FileHash[]
+  } {
+  const oldMap = new Map(oldHashes.map(f => [f.path, f]))
+  const newMap = new Map(newHashes.map(f => [f.path, f]))
+
+  const added: FileHash[] = []
+  const modified: FileHash[] = []
+  const deleted: FileHash[] = []
+
+  // Find added and modified
+  for (const [path, newFile] of newMap) {
+    const oldFile = oldMap.get(path)
+
+    if (!oldFile) {
+      added.push(newFile)
+    }
+    else if (oldFile.hash !== newFile.hash) {
+      modified.push(newFile)
+    }
+  }
+
+  // Find deleted
+  for (const [path, oldFile] of oldMap) {
+    if (!newMap.has(path)) {
+      deleted.push(oldFile)
+    }
+  }
+
+  return { added, modified, deleted }
+}
+
+/**
+ * Cache for file hashes
+ */
+export class HashCache {
+  private cache: Map<string, { hash: string, mtime: number, size: number }>
+
+  constructor() {
+    this.cache = new Map()
+  }
+
+  /**
+   * Get cached hash if file hasn't changed
+   */
+  get(filePath: string): string | undefined {
+    const stats = fs.statSync(filePath)
+    const cached = this.cache.get(filePath)
+
+    if (cached && cached.mtime === stats.mtimeMs && cached.size === stats.size) {
+      return cached.hash
+    }
+
+    return undefined
+  }
+
+  /**
+   * Cache a file hash
+   */
+  set(filePath: string, hash: string): void {
+    const stats = fs.statSync(filePath)
+
+    this.cache.set(filePath, {
+      hash,
+      mtime: stats.mtimeMs,
+      size: stats.size,
+    })
+  }
+
+  /**
+   * Get or compute hash
+   */
+  async getOrCompute(filePath: string, options: HashOptions = {}): Promise<string> {
+    const cached = this.get(filePath)
+
+    if (cached) {
+      return cached
+    }
+
+    const hash = await hashFile(filePath, options)
+    this.set(filePath, hash)
+
+    return hash
+  }
+
+  /**
+   * Clear cache
+   */
+  clear(): void {
+    this.cache.clear()
+  }
+}

package/src/utils/index.ts

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

package/src/utils/parallel.ts

@@ -0,0 +1,294 @@
+/**
+ * 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 async function parallel<T>(
+  tasks: (() => Promise<T>)[],
+  options: ParallelOptions = {},
+): Promise<ParallelResult<T>> {
+  const concurrency = options.concurrency || 5
+  const stopOnError = options.stopOnError ?? true
+
+  const results: T[] = []
+  const errors: Error[] = []
+  const startTime = Date.now()
+
+  const queue = [...tasks]
+  const running: Promise<void>[] = []
+
+  async function runTask(task: () => Promise<T>, index: number): Promise<void> {
+    try {
+      const result = await task()
+      results[index] = result
+    }
+    catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error))
+      errors.push(err)
+
+      if (stopOnError) {
+        queue.length = 0 // Clear queue
+        throw err
+      }
+    }
+  }
+
+  let index = 0
+  while (queue.length > 0 || running.length > 0) {
+    // Fill up to concurrency limit
+    while (running.length < concurrency && queue.length > 0) {
+      const task = queue.shift()!
+      const currentIndex = index++
+      const promise = runTask(task, currentIndex)
+      running.push(promise)
+    }
+
+    // Wait for at least one task to complete
+    if (running.length > 0) {
+      await Promise.race(running)
+
+      // Remove completed tasks
+      for (let i = running.length - 1; i >= 0; i--) {
+        const settled = await Promise.race([
+          running[i].then(() => true),
+          Promise.resolve(false),
+        ])
+
+        if (settled) {
+          running.splice(i, 1)
+        }
+      }
+    }
+
+    // Stop if error occurred and stopOnError is true
+    if (stopOnError && errors.length > 0) {
+      break
+    }
+  }
+
+  const duration = Date.now() - startTime
+
+  return {
+    results: results.filter(r => r !== undefined),
+    errors,
+    duration,
+  }
+}
+
+/**
+ * Execute tasks in batches with controlled concurrency
+ */
+export async function batch<T, R>(
+  items: T[],
+  processor: (item: T) => Promise<R>,
+  options: ParallelOptions = {},
+): Promise<ParallelResult<R>> {
+  const tasks = items.map(item => () => processor(item))
+  return parallel(tasks, options)
+}
+
+/**
+ * Map over array with parallel execution
+ */
+export async function parallelMap<T, R>(
+  items: T[],
+  mapper: (item: T, index: number) => Promise<R>,
+  concurrency: number = 5,
+): Promise<R[]> {
+  const tasks = items.map((item, index) => () => mapper(item, index))
+  const result = await parallel(tasks, { concurrency, stopOnError: false })
+
+  if (result.errors.length > 0) {
+    throw new AggregateError(result.errors, 'Parallel map failed')
+  }
+
+  return result.results
+}
+
+/**
+ * Execute tasks with retry logic
+ */
+export async function parallelWithRetry<T>(
+  tasks: (() => Promise<T>)[],
+  options: ParallelOptions & { retries?: number, retryDelay?: number } = {},
+): Promise<ParallelResult<T>> {
+  const retries = options.retries || 3
+  const retryDelay = options.retryDelay || 1000
+
+  const retriableTasks = tasks.map(task => async () => {
+    let lastError: Error | undefined
+
+    for (let attempt = 0; attempt <= retries; attempt++) {
+      try {
+        return await task()
+      }
+      catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error))
+
+        // Wait before retry (except on last attempt)
+        if (attempt < retries) {
+          await sleep(retryDelay * (attempt + 1)) // Exponential backoff
+        }
+      }
+    }
+
+    throw lastError
+  })
+
+  return parallel(retriableTasks, options)
+}
+
+/**
+ * Execute tasks in sequence (one after another)
+ */
+export async function sequence<T>(
+  tasks: (() => Promise<T>)[],
+): Promise<T[]> {
+  const results: T[] = []
+
+  for (const task of tasks) {
+    const result = await task()
+    results.push(result)
+  }
+
+  return results
+}
+
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+/**
+ * Execute tasks with timeout
+ */
+export async function withTimeout<T>(
+  task: () => Promise<T>,
+  timeoutMs: number,
+  timeoutMessage: string = 'Operation timed out',
+): Promise<T> {
+  return Promise.race([
+    task(),
+    new Promise<T>((_, reject) =>
+      setTimeout(() => reject(new Error(timeoutMessage)), timeoutMs),
+    ),
+  ])
+}
+
+/**
+ * Rate limiter for API calls
+ */
+export class RateLimiter {
+  private queue: (() => void)[] = []
+  private running = 0
+  private lastExecution = 0
+
+  constructor(
+    private maxConcurrent: number = 5,
+    private minInterval: number = 100, // milliseconds between calls
+  ) {}
+
+  /**
+   * Execute task with rate limiting
+   */
+  async execute<T>(task: () => Promise<T>): Promise<T> {
+    // Wait for available slot
+    await this.waitForSlot()
+
+    this.running++
+    this.lastExecution = Date.now()
+
+    try {
+      return await task()
+    }
+    finally {
+      this.running--
+      this.processQueue()
+    }
+  }
+
+  /**
+   * Wait for available execution slot
+   */
+  private waitForSlot(): Promise<void> {
+    if (this.running < this.maxConcurrent) {
+      const timeSinceLastExecution = Date.now() - this.lastExecution
+
+      if (timeSinceLastExecution >= this.minInterval) {
+        return Promise.resolve()
+      }
+
+      return sleep(this.minInterval - timeSinceLastExecution)
+    }
+
+    return new Promise(resolve => this.queue.push(resolve))
+  }
+
+  /**
+   * Process queued tasks
+   */
+  private processQueue(): void {
+    if (this.queue.length > 0 && this.running < this.maxConcurrent) {
+      const resolve = this.queue.shift()!
+      resolve()
+    }
+  }
+
+  /**
+   * Get stats
+   */
+  stats(): { running: number, queued: number } {
+    return {
+      running: this.running,
+      queued: this.queue.length,
+    }
+  }
+}
+
+/**
+ * Chunk array into smaller batches
+ */
+export function chunk<T>(array: T[], size: number): T[][] {
+  const chunks: T[][] = []
+
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size))
+  }
+
+  return chunks
+}
+
+/**
+ * Process array in chunks with parallel execution
+ */
+export async function processInChunks<T, R>(
+  items: T[],
+  chunkSize: number,
+  processor: (chunk: T[]) => Promise<R[]>,
+): Promise<R[]> {
+  const chunks = chunk(items, chunkSize)
+  const results: R[] = []
+
+  for (const currentChunk of chunks) {
+    const chunkResults = await processor(currentChunk)
+    results.push(...chunkResults)
+  }
+
+  return results
+}