typelex / scripts / publish-all.sh

#!/bin/bash
set -e

# Usage: ./scripts/publish-all.sh <version> [--dry]
# Example: ./scripts/publish-all.sh 0.4.0
# Example: ./scripts/publish-all.sh 0.4.0 --dry

if [ -z "$1" ]; then
  echo "Error: Version argument required"
  echo "Usage: ./scripts/publish-all.sh <version> [--dry]"
  echo "Example: ./scripts/publish-all.sh 0.4.0"
  echo "Example: ./scripts/publish-all.sh 0.4.0 --dry"
  exit 1
fi

VERSION="$1"
DRY_RUN=false

if [ "$2" = "--dry" ]; then
  DRY_RUN=true
fi

# Validate version format (basic semver check)
if ! [[ "$VERSION" =~ ^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.]+)?$ ]]; then
  echo "Error: Invalid version format. Use semver format (e.g., 0.4.0 or 0.4.0-beta.1)"
  exit 1
fi

echo "📦 Publishing all packages at version $VERSION"
echo ""

# Get the root directory
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$ROOT_DIR"

# Find all package.json files in packages/*
ALL_PACKAGES=($(find packages -maxdepth 2 -name "package.json" -not -path "*/node_modules/*" | sort))

# Filter out private packages and topologically sort by dependencies
PACKAGES=($(node -e "
  const fs = require('fs');
  const allPackages = process.argv.slice(1);

  // Filter out private packages
  const packages = allPackages.filter(path => {
    const pkg = JSON.parse(fs.readFileSync(path, 'utf-8'));
    return !pkg.private;
  });

  // Build dependency graph
  const graph = new Map();
  const pkgNames = new Map();

  packages.forEach(path => {
    const pkg = JSON.parse(fs.readFileSync(path, 'utf-8'));
    pkgNames.set(pkg.name, path);

    const deps = new Set();
    [pkg.dependencies, pkg.devDependencies, pkg.peerDependencies].forEach(depObj => {
      if (depObj) {
        Object.keys(depObj).forEach(dep => {
          if (dep.startsWith('@typelex/')) {
            deps.add(dep);
          }
        });
      }
    });

    graph.set(pkg.name, deps);
  });

  // Topological sort - packages with more dependents first
  const sorted = [];
  const processed = new Set();

  function visit(pkgName) {
    if (processed.has(pkgName)) return;
    processed.add(pkgName);

    // Visit all dependencies first
    const deps = graph.get(pkgName) || new Set();
    deps.forEach(dep => {
      if (graph.has(dep)) {
        visit(dep);
      }
    });

    sorted.push(pkgName);
  }

  // Visit all packages
  graph.forEach((_, pkgName) => visit(pkgName));

  // Output sorted package paths
  sorted.forEach(name => {
    if (pkgNames.has(name)) {
      console.log(pkgNames.get(name));
    }
  });
" "${ALL_PACKAGES[@]}"))

if [ ${#PACKAGES[@]} -eq 0 ]; then
  echo "Error: No publishable packages found in packages/"
  exit 1
fi

echo "Found ${#PACKAGES[@]} publishable packages (topologically sorted):"
for pkg in "${PACKAGES[@]}"; do
  PKG_NAME=$(node -p "require('./$pkg').name")
  echo "  - $PKG_NAME"
done
echo ""

# Update all package.json files with the new version
echo "🔄 Updating versions in all packages..."
for pkg in "${PACKAGES[@]}"; do
  PKG_DIR=$(dirname "$pkg")
  PKG_NAME=$(node -p "require('./$pkg').name")

  echo "  Updating $PKG_NAME..."

  # Update version
  node -e "
    const fs = require('fs');
    const path = '$pkg';
    const pkg = require('./' + path);
    pkg.version = '$VERSION';

    // Helper to preserve semver prefix (^, ~, etc.) and workspace: protocol
    function updateVersion(currentVersion, newVersion) {
      // Preserve workspace: protocol for monorepo
      if (currentVersion.startsWith('workspace:')) {
        return currentVersion;
      }
      // Preserve semver prefix
      const match = currentVersion.match(/^([~^>=<]*)(.*)$/);
      if (match) {
        return match[1] + newVersion;
      }
      return newVersion;
    }

    // Helper to update dependencies
    function updateDeps(deps) {
      if (!deps) return;
      for (const dep in deps) {
        if (dep.startsWith('@typelex/')) {
          deps[dep] = updateVersion(deps[dep], '$VERSION');
        }
      }
    }

    updateDeps(pkg.dependencies);
    updateDeps(pkg.devDependencies);
    updateDeps(pkg.peerDependencies);

    fs.writeFileSync(path, JSON.stringify(pkg, null, 2) + '\n');
  "
done

echo ""
echo "✅ All versions updated to $VERSION"
echo ""

if [ "$DRY_RUN" = true ]; then
  echo "✅ Dry run complete! Version updates have been applied."
  echo ""
  echo "📋 Updated packages:"
  for pkg in "${PACKAGES[@]}"; do
    PKG_NAME=$(node -p "require('./$pkg').name")
    echo "  - $PKG_NAME@$VERSION"
  done
  echo ""
  echo "💡 Review the changes, then run without --dry to publish."
  exit 0
fi

# Ask for confirmation
read -p "🚀 Ready to publish all packages to npm. Continue? (y/N) " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
  echo "❌ Publish cancelled"
  exit 1
fi

echo ""
echo "📤 Publishing packages..."
echo ""

# Publish each package
PUBLISHED=()
FAILED=()

for pkg in "${PACKAGES[@]}"; do
  PKG_DIR=$(dirname "$pkg")
  PKG_NAME=$(node -p "require('./$pkg').name")

  echo "Publishing $PKG_NAME..."

  if (cd "$PKG_DIR" && npm publish --access public); then
    echo "  ✅ $PKG_NAME published successfully"
    PUBLISHED+=("$PKG_NAME")
  else
    echo "  ❌ $PKG_NAME failed to publish"
    FAILED+=("$PKG_NAME")
  fi

  echo ""
done

# Summary
echo "📊 Summary:"
echo ""
echo "Published (${#PUBLISHED[@]}):"
for pkg in "${PUBLISHED[@]}"; do
  echo "  ✅ $pkg"
done

if [ ${#FAILED[@]} -gt 0 ]; then
  echo ""
  echo "Failed (${#FAILED[@]}):"
  for pkg in "${FAILED[@]}"; do
    echo "  ❌ $pkg"
  done
  exit 1
fi

echo ""
echo "🎉 All packages published successfully!"