@crossdelta/platform-sdk 0.14.0 → 0.16.0

package/bin/templates/workspace/.github/workflows/build-and-deploy.yml.hbs

@@ -0,0 +1,232 @@
+name: 🚀 Build and Deploy
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'apps/*/**'
+      - 'services/*/**'
+      - 'infra/**'
+      - 'bun.lock'
+      - '.github/workflows/**'
+  workflow_run:
+    workflows: ['📦 Publish Packages']
+    types:
+      - completed
+
+permissions:
+  contents: read
+  packages: write
+
+concurrency:
+  group: deploy-$\{{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  SCOPE_ROOTS: apps,services
+  REGISTRY: ghcr.io/$\{{ github.repository_owner }}/$\{{ github.event.repository.name }}
+  PULUMI_STACK: $\{{ vars.PULUMI_STACK_BASE }}/$\{{ github.ref_name == 'main' && 'production' || github.ref_name }}
+  WORKFLOW_HEAD_SHA: $\{{ github.event_name == 'workflow_run' && github.event.workflow_run.head_sha || github.sha }}
+  WORKFLOW_BASE_SHA_INPUT: $\{{ github.event_name == 'workflow_run' && github.event.workflow_run.head_commit.id || github.event.before }}
+
+jobs:
+  prepare-scopes:
+    name: 🧪 Prepare Scopes
+    runs-on: ubuntu-latest
+    if: github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success'
+    outputs:
+      scopes: $\{{ steps.scope-generator.outputs.scopes }}
+      scope_count: $\{{ steps.scope-generator.outputs.scopes_count }}
+      infrastructure_changed: $\{{ steps.infra-check.outputs.changed }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: $\{{ env.WORKFLOW_HEAD_SHA }}
+
+      - name: Set commit range
+        run: |
+          set -euo pipefail
+          HEAD_SHA="${WORKFLOW_HEAD_SHA}"
+          BASE_SHA="${WORKFLOW_BASE_SHA_INPUT}"
+          NULL_SHA="0000000000000000000000000000000000000000"
+          if [ -z "$BASE_SHA" ] || [ "$BASE_SHA" = "$NULL_SHA" ]; then
+            if git rev-parse "${HEAD_SHA}^" >/dev/null 2>&1; then
+              BASE_SHA=$(git rev-parse "${HEAD_SHA}^")
+            else
+              BASE_SHA="$HEAD_SHA"
+            fi
+          fi
+          echo "GITHUB_SHA=$HEAD_SHA" >> "$GITHUB_ENV"
+          echo "GITHUB_EVENT_BEFORE=$BASE_SHA" >> "$GITHUB_ENV"
+
+      - name: Check for infrastructure changes
+        id: infra-check
+        uses: dorny/paths-filter@v3
+        with:
+          filters: |
+            changed:
+              - 'infra/**'
+
+      - name: Generate scope matrix
+        id: scope-generator
+        uses: ./.github/actions/generate-scope-matrix
+        with:
+          scope-roots: $\{{ env.SCOPE_ROOTS }}
+
+  build:
+    if: needs.prepare-scopes.outputs.scope_count && needs.prepare-scopes.outputs.scope_count != '0'
+    needs: prepare-scopes
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        scope: $\{{ fromJson(needs.prepare-scopes.outputs.scopes) }}
+    name: 🐳 Build $\{{ matrix.scope.shortName }}
+    env:
+      DOCKER_BUILDKIT: 1
+      IMAGE_TAG: $\{{ github.sha }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 2
+          ref: $\{{ env.WORKFLOW_HEAD_SHA }}
+
+      - name: Set scope metadata
+        run: |
+          echo "SCOPE_DIR=$\{{ matrix.scope.dir }}" >> $GITHUB_ENV
+          echo "scope_name=$\{{ matrix.scope.shortName }}" >> $GITHUB_OUTPUT
+
+      - name: Setup Bun and install dependencies
+        uses: ./.github/actions/setup-bun-install
+        with:
+          enable-cache: 'true'
+          cache-key: bun-$\{{ runner.os }}-$\{{ hashFiles('bun.lock') }}
+          cache-restore-keys: bun-$\{{ runner.os }}-
+          npm-token: $\{{ secrets.NPM_TOKEN }}
+
+      - name: Prune
+        run: |
+          bunx turbo prune --scope=$\{{ matrix.scope.name }} --docker --out-dir out/$\{{ matrix.scope.shortName }}
+
+      - name: Compute scope checksum
+        id: scope-checksum
+        run: |
+          set -euo pipefail
+          cd "out/$\{{ matrix.scope.shortName }}"
+          HASH=$(find . -type f -print0 | sort -z | xargs -0 sha256sum | sha256sum)
+          HASH=${HASH%% *}
+          echo "scope_hash=$HASH" >> $GITHUB_OUTPUT
+
+      - name: Use scope checksum as image tag
+        run: echo "IMAGE_TAG=$\{{ steps.scope-checksum.outputs.scope_hash }}" >> $GITHUB_ENV
+
+      - name: Check if image tag exists
+        id: tag-check
+        uses: ./.github/actions/check-image-tag-exists
+        with:
+          scope-short-name: $\{{ matrix.scope.shortName }}
+          image-tag: $\{{ env.IMAGE_TAG }}
+          github-token: $\{{ secrets.GITHUB_TOKEN }}
+
+      - name: Set up Docker Buildx
+        if: steps.tag-check.outputs.exists != 'true'
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to GitHub Packages (GHCR)
+        if: steps.tag-check.outputs.exists != 'true'
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: $\{{ github.actor }}
+          password: $\{{ secrets.GITHUB_TOKEN }}
+
+      - name: Prepare build context
+        if: steps.tag-check.outputs.exists != 'true'
+        uses: ./.github/actions/prepare-build-context
+        with:
+          scope-short-name: $\{{ matrix.scope.shortName }}
+          scope-dir: $\{{ matrix.scope.dir }}
+
+      - name: Build and push image
+        if: steps.tag-check.outputs.exists != 'true'
+        uses: docker/build-push-action@v5
+        env:
+          NPM_TOKEN: $\{{ secrets.NPM_TOKEN }}
+        with:
+          context: out/$\{{ matrix.scope.shortName }}/full
+          push: true
+          tags: |
+            $\{{ env.REGISTRY }}/$\{{ matrix.scope.shortName }}:$\{{ env.IMAGE_TAG }}
+            $\{{ env.REGISTRY }}/$\{{ matrix.scope.shortName }}:latest
+          secrets: |
+            NPM_TOKEN=$\{{ env.NPM_TOKEN }}
+
+      - name: Mark this scope as changed
+        run: |
+          mkdir -p .changed/$\{{ matrix.scope.shortName }}
+          echo "$\{{ matrix.scope.shortName }}" > .changed/$\{{ matrix.scope.shortName }}/scope.txt
+          printf '{"shortName":"%s","imageTag":"%s"}\n' "$\{{ matrix.scope.shortName }}" "$\{{ env.IMAGE_TAG }}" > .changed/$\{{ matrix.scope.shortName }}/metadata.json
+
+      - name: Upload change marker
+        uses: actions/upload-artifact@v4
+        with:
+          name: changed-$\{{ matrix.scope.shortName }}
+          path: .changed/$\{{ matrix.scope.shortName }}
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [build, prepare-scopes]
+    if: |
+      always() &&
+      needs.prepare-scopes.result == 'success' &&
+      needs.build.result != 'failure' &&
+      (needs.prepare-scopes.outputs.scope_count != '0' || needs.prepare-scopes.outputs.infrastructure_changed == 'true')
+    name: 🌍 Deploy
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: $\{{ env.WORKFLOW_HEAD_SHA }}
+      - name: Download all change markers
+        uses: actions/download-artifact@v4
+        with:
+          path: .artifacts
+
+      - name: Detect skipped services
+        id: detect_skipped
+        uses: ./.github/actions/detect-skipped-services
+
+      - name: Resolve scope image tags
+        id: resolve_scope_tags
+        uses: ./.github/actions/resolve-scope-tags
+        with:
+          markers-dir: .artifacts
+          scope-roots: $\{{ env.SCOPE_ROOTS }}
+          repository-owner: $\{{ github.repository_owner }}
+          allow-missing-scopes: $\{{ steps.detect_skipped.outputs.skipped-services }}
+          github-token: $\{{ secrets.GITHUB_TOKEN }}
+
+      - name: Setup Bun and install dependencies
+        uses: ./.github/actions/setup-bun-install
+        with:
+          enable-cache: 'true'
+          cache-key: bun-$\{{ runner.os }}-$\{{ hashFiles('bun.lock') }}
+          cache-restore-keys: bun-$\{{ runner.os }}-
+          npm-token: $\{{ secrets.NPM_TOKEN }}
+
+      - name: Build infrastructure package
+        run: |
+          bun run --cwd packages/infrastructure build
+
+      - name: Pulumi up
+        uses: pulumi/actions@v6
+        with:
+          command: up
+          suppress-progress: true
+          comment-on-summary: true
+          stack-name: $\{{ env.PULUMI_STACK }}
+          work-dir: infra
+        env:
+          PULUMI_ACCESS_TOKEN: $\{{ secrets.PULUMI_ACCESS_TOKEN }}
+          DIGITALOCEAN_TOKEN: $\{{ secrets.DIGITALOCEAN_TOKEN }}
+          SCOPE_IMAGE_TAGS: $\{{ steps.resolve_scope_tags.outputs.scope_image_tags }}

package/bin/templates/workspace/.github/workflows/lint-and-tests.yml.hbs

@@ -0,0 +1,32 @@
+name: ✅ Pull Request Checks
+
+on:
+  pull_request:
+    branches:
+      - main
+
+concurrency:
+  group: $\{{ github.workflow }}-$\{{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    env:
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Bun and install dependencies
+        uses: ./.github/actions/setup-bun-install
+        with:
+          enable-cache: 'true'
+          cache-key: bun-$\{{ runner.os }}-$\{{ hashFiles('bun.lock') }}
+          cache-restore-keys: bun-$\{{ runner.os }}-
+
+      - name: Run Linter
+        run: bun run --if-present lint
+
+      - name: Run Tests
+        run: bun run --if-present test

package/bin/templates/workspace/.github/workflows/publish-packages.yml

@@ -0,0 +1,188 @@
+name: 📦 Publish Packages
+
+on:
+  push:
+    branches:
+      - main
+    paths:
+      - 'packages/*/**'
+  workflow_dispatch:
+    inputs:
+      package:
+        description: 'Package to publish (slug from packages/ directory, or "all")'
+        type: string
+        default: all
+        required: true
+
+permissions:
+  contents: write
+
+jobs:
+  determine-packages:
+    if: github.actor != 'github-actions[bot]'
+    runs-on: ubuntu-latest
+    outputs:
+      packages: ${{ steps.set-matrix.outputs.packages }}
+      count: ${{ steps.set-matrix.outputs.count }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Detect changed packages
+        id: changed
+        uses: tj-actions/changed-files@v45
+        with:
+          json: true
+          dir_names: true
+          dir_names_max_depth: 2
+          files: packages/*/**
+
+      - name: Build package matrix
+        id: set-matrix
+        env:
+          INPUT_PACKAGE: ${{ github.event.inputs.package || '' }}
+          CHANGED_DIRS: ${{ steps.changed.outputs.all_changed_files }}
+        run: |
+          declare -a packages=()
+          declare -A changed_packages
+          
+          # Parse changed directories from JSON
+          if [ "${{ github.event_name }}" == "push" ] && [ -n "$CHANGED_DIRS" ]; then
+            for dir in $(echo "$CHANGED_DIRS" | jq -r '.[]'); do
+              if [[ $dir =~ ^packages/([^/]+)$ ]]; then
+                changed_packages["${BASH_REMATCH[1]}"]=1
+              fi
+            done
+          fi
+          
+          # Iterate all packages
+          for dir in packages/*/; do
+            [ ! -f "$dir/package.json" ] && continue
+            
+            slug=$(basename "$dir")
+            name=$(jq -r '.name // empty' "$dir/package.json")
+            is_private=$(jq -r '.private // false' "$dir/package.json")
+            
+            [ "$is_private" = "true" ] && continue
+            [ -z "$name" ] && continue
+            
+            # Include package?
+            should_include=false
+            if [ -n "$INPUT_PACKAGE" ]; then
+              [ "$INPUT_PACKAGE" = "all" ] || [ "$INPUT_PACKAGE" = "$slug" ] && should_include=true
+            else
+              [ -n "${changed_packages[$slug]}" ] && should_include=true
+            fi
+            
+            [ "$should_include" = true ] && packages+=("{\"name\":\"$name\",\"dir\":\"$dir\"}")
+          done
+          
+          # Output
+          if [ ${#packages[@]} -eq 0 ]; then
+            echo "packages=[]" >> "$GITHUB_OUTPUT"
+            echo "count=0" >> "$GITHUB_OUTPUT"
+          else
+            echo "packages=[$(IFS=,; echo "${packages[*]}")]" >> "$GITHUB_OUTPUT"
+            echo "count=${#packages[@]}" >> "$GITHUB_OUTPUT"
+            echo "📦 Packages to publish: ${#packages[@]}"
+          fi
+
+  # Build all packages in dependency order using Turborepo
+  # This ensures infrastructure is built AFTER cloudevents (which it depends on)
+  build-all:
+    name: Build all packages
+    needs: determine-packages
+    if: needs.determine-packages.outputs.count != '0'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+      - name: Install dependencies
+        run: bun install
+
+      - name: Build all packages
+        run: |
+          # Turborepo automatically builds in dependency order (see turbo.json)
+          # Example order: cloudevents -> infrastructure, telemetry, platform-sdk
+          bunx turbo run build --filter='./packages/*'
+
+      - name: Upload build artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-packages
+          path: packages/*/dist
+          retention-days: 1
+
+  # Publish packages sequentially (max-parallel: 1)
+  # Build artifacts are already available from build-all job
+  publish:
+    name: Publish ${{ matrix.package.name }}
+    needs: [determine-packages, build-all]
+    if: needs.determine-packages.outputs.count != '0'
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 1
+      matrix:
+        package: ${{ fromJson(needs.determine-packages.outputs.packages) }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: oven-sh/setup-bun@v2
+      
+      - name: Install dependencies
+        run: bun install --frozen-lockfile
+      
+      - name: Download build artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist-packages
+          path: packages/
+
+      - name: Verify build artifacts
+        run: |
+          if [ ! -d "${{ matrix.package.dir }}/dist" ]; then
+            echo "❌ Build artifacts missing for ${{ matrix.package.name }}"
+            exit 1
+          fi
+          echo "✅ Build artifacts found for ${{ matrix.package.name }}"
+
+      - name: Bump version
+        id: bump
+        working-directory: ${{ matrix.package.dir }}
+        run: |
+          CURRENT=$(jq -r '.version' package.json)
+          PUBLISHED=$(npm view "${{ matrix.package.name }}" version 2>/dev/null || echo "0.0.0")
+          
+          if [ "$CURRENT" = "$PUBLISHED" ]; then
+            # Auto-bump patch version
+            NEW="${CURRENT%.*}.$((${CURRENT##*.} + 1))"
+            jq --arg v "$NEW" '.version = $v' package.json > tmp && mv tmp package.json
+            echo "version=$NEW" >> "$GITHUB_OUTPUT"
+            echo "bumped=true" >> "$GITHUB_OUTPUT"
+            echo "📦 Bumped: $CURRENT → $NEW"
+          else
+            # Use manual version
+            echo "version=$CURRENT" >> "$GITHUB_OUTPUT"
+            echo "bumped=false" >> "$GITHUB_OUTPUT"
+            echo "📦 Manual version: $CURRENT (npm: $PUBLISHED)"
+          fi
+
+      - name: Publish to npm
+        working-directory: ${{ matrix.package.dir }}
+        env:
+          NPM_CONFIG_TOKEN: ${{ secrets.NPM_TOKEN }}
+        run: |
+          echo "📦 Publishing ${{ matrix.package.name }}@${{ steps.bump.outputs.version }}"
+          bun publish --access=public --provenance --tolerate-republish
+
+      - name: Commit version bump
+        if: steps.bump.outputs.bumped == 'true'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git add "${{ matrix.package.dir }}/package.json"
+          git diff --cached --quiet || git commit -m "chore(release): ${{ matrix.package.name }}@${{ steps.bump.outputs.version }}"
+          git pull --rebase origin ${{ github.ref_name }} && git push || true

package/bin/templates/workspace/infra/package.json.hbs

@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@crossdelta/cloudevents": "^0.5.3",
-    "@crossdelta/infrastructure": "^0.5.2",
+    "@crossdelta/infrastructure": "^0.5.3",
     "{{scope}}/contracts": "workspace:*",
     "@pulumi/digitalocean": "^4.55.0",
     "@pulumi/kubernetes": "^4.21.0",

package/bin/templates/workspace/packages/contracts/package.json.hbs

@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@crossdelta/cloudevents": "^0.5.3",
-    "@crossdelta/infrastructure": "^0.5.2",
+    "@crossdelta/infrastructure": "^0.5.3",
     "zod": "^4.0.0"
   },
   "devDependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossdelta/platform-sdk",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Platform toolkit for event-driven microservices — keeping code and infrastructure in lockstep.",
   "keywords": [
     "cli",
@@ -87,7 +87,7 @@
   "build:schematics:copy": "cp -R schematics/* dist/schematics && find dist/schematics -name '*.ts' -delete",
   "build:schematics": "npm run build:schematics:transpile && npm run build:schematics:copy",
   "build": "npm run build:cli && npm run build:schematics && npm run build:cli:copy",
-  "prepublishOnly": "[ -n \"$CI_SKIP_BUILD\" ] || npm run build",
+  "prepublishOnly": "npm run build",
   "lint": "biome lint --fix",
   "test": "bun test",
   "test:watch": "bun test --watch"