@crossdelta/platform-sdk 0.14.0 → 0.15.0

package/bin/templates/workspace/.github/actions/generate-scope-matrix/index.js

@@ -0,0 +1,355 @@
+/**
+ * Generate Scope Matrix Action
+ *
+ * Discovers Docker-enabled scopes in a monorepo and generates a GitHub Actions
+ * matrix for building only the scopes that have changed between commits.
+ *
+ * A "scope" is a directory containing a Dockerfile. Scopes are discovered by
+ * scanning configured root directories (default: apps, services).
+ *
+ * @example
+ * // In a workflow:
+ * - uses: ./.github/actions/generate-scope-matrix
+ *   with:
+ *     scope-roots: apps,services
+ *
+ * @outputs scopes - JSON array of scope objects [{name, shortName, dir, run}]
+ * @outputs scopes_count - Number of scopes in the matrix
+ */
+
+const { appendFileSync } = require('node:fs')
+const { spawnSync } = require('node:child_process')
+const { existsSync, readdirSync, readFileSync, statSync } = require('node:fs')
+const { basename, join, relative } = require('node:path')
+
+/** Default directories to scan for scopes (Turborepo convention) */
+const defaultRoots = ['apps', 'services']
+
+/** Keys in GitHub event payload that contain changed file paths */
+const changedKeys = ['added', 'modified', 'removed']
+
+/**
+ * Builds environment variable keys for GitHub Actions inputs.
+ * GitHub converts input names to uppercase and replaces special chars with underscores.
+ * @param {string} name - Input name (e.g., 'scope-roots')
+ * @returns {string[]} Possible environment variable keys
+ */
+const buildInputKeys = (name) => {
+  const trimmed = name.trim()
+  const upper = trimmed.toUpperCase()
+  const normalized = upper.replace(/[^A-Z0-9]+/g, '_')
+  return Array.from(new Set([`INPUT_${upper}`, `INPUT_${normalized}`]))
+}
+
+/**
+ * Retrieves a GitHub Actions input value from environment variables.
+ * @param {string} name - Input name as defined in action.yml
+ * @param {Object} options - Options
+ * @param {string} [options.defaultValue=''] - Default value if input is not set
+ * @returns {string} The input value
+ */
+const getInput = (name, { defaultValue = '' } = {}) => {
+  const keys = buildInputKeys(name)
+  const raw = keys.map((key) => process.env[key]).find((value) => typeof value === 'string')
+  const value = typeof raw === 'string' ? raw.trim() : defaultValue
+  return value
+}
+
+/**
+ * Sets a GitHub Actions output value.
+ * Writes to GITHUB_OUTPUT file or logs to console if not in Actions environment.
+ * @param {string} name - Output name
+ * @param {string|object} value - Output value (objects are JSON stringified)
+ */
+const setOutput = (name, value) => {
+  const outputFile = process.env.GITHUB_OUTPUT
+  const stringValue = typeof value === 'string' ? value : JSON.stringify(value)
+
+  if (outputFile) {
+    appendFileSync(outputFile, `${name}=${stringValue}\n`)
+  } else {
+    console.log(`${name}=${stringValue}`)
+  }
+}
+
+/**
+ * Loads root directories to scan for scopes.
+ * Parses the 'scope-roots' input or uses defaults (apps, services).
+ * @returns {string[]} Array of root directory paths
+ */
+const loadRoots = () => {
+  const envRoots = getInput('scope-roots')
+
+  if (!envRoots) return defaultRoots
+
+  const parsed = envRoots
+    .split(/[^a-zA-Z0-9._-]+/)
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+
+  return parsed.length > 0 ? parsed : defaultRoots
+}
+
+/**
+ * Loads short names that should be forced into the matrix regardless of changes.
+ * Useful for deploying specific services manually.
+ * @returns {string[]} Array of short names to force-include
+ */
+const loadForcedShortNames = () => {
+  const envValue = getInput('force-scope-short-names')
+
+  if (!envValue) return []
+
+  return Array.from(
+    new Set(
+      envValue
+        .split(/[^a-zA-Z0-9._-]+/)
+        .map((entry) => entry.trim())
+        .filter(Boolean),
+    ),
+  )
+}
+
+/**
+ * Resolves the scope name from package.json or falls back to directory name.
+ * @param {string} entryPath - Path to the scope directory
+ * @param {string} fallback - Fallback name if package.json is not found
+ * @returns {string} The scope name
+ */
+const resolveScopeName = (entryPath, fallback) => {
+  const pkgPath = join(entryPath, 'package.json')
+
+  if (!existsSync(pkgPath)) return fallback
+
+  try {
+    const raw = readFileSync(pkgPath, 'utf8')
+    const pkg = JSON.parse(raw)
+    if (typeof pkg.name === 'string' && pkg.name.trim().length > 0) {
+      return pkg.name
+    }
+  } catch (error) {
+    console.error(`Failed to read package.json for ${entryPath}:`, error)
+    process.exit(1)
+  }
+
+  return fallback
+}
+
+/**
+ * Processes a single directory entry and adds it to scopes if it contains a Dockerfile.
+ * @param {string} root - Root directory path
+ * @param {string} entry - Directory entry name
+ * @param {Map} scopes - Map to store discovered scopes
+ */
+const processScopeEntry = (root, entry, scopes) => {
+  const entryPath = join(root, entry)
+
+  const isDirectory = statSync(entryPath).isDirectory()
+  if (!isDirectory) return
+
+  const dockerfilePath = join(entryPath, 'Dockerfile')
+  const hasDockerfile = existsSync(dockerfilePath)
+  if (!hasDockerfile) return
+
+  const scopeName = resolveScopeName(entryPath, entry)
+  const isDuplicateScope = scopes.has(scopeName)
+  if (isDuplicateScope) return
+
+  const relativeDir = relative(process.cwd(), entryPath).replace(/\\/g, '/')
+  scopes.set(scopeName, {
+    name: scopeName,
+    dir: relativeDir,
+    shortName: basename(relativeDir),
+  })
+}
+
+/**
+ * Discovers all Docker-enabled scopes in the given root directories.
+ * @param {string[]} roots - Array of root directory paths to scan
+ * @returns {Map<string, {name: string, dir: string, shortName: string}>} Map of discovered scopes
+ */
+const discoverScopes = (roots) => {
+  const scopes = new Map()
+
+  for (const root of roots) {
+    let entries = []
+    try {
+      entries = readdirSync(root)
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        continue
+      }
+      throw error
+    }
+
+    for (const entry of entries) {
+      processScopeEntry(root, entry, scopes)
+    }
+  }
+
+  return scopes
+}
+
+/**
+ * Loads changed files from the GitHub event payload.
+ * @param {string} eventPath - Path to the GitHub event JSON file
+ * @returns {string[]} Array of changed file paths
+ */
+const loadEventChangedFiles = (eventPath) => {
+  if (!eventPath || !existsSync(eventPath)) {
+    return []
+  }
+
+  try {
+    const payloadRaw = readFileSync(eventPath, 'utf8')
+    const payload = JSON.parse(payloadRaw)
+    const commits = Array.isArray(payload.commits) ? payload.commits : []
+    const files = new Set()
+
+    commits.forEach((commit) => {
+      changedKeys.forEach((key) => {
+        if (!Array.isArray(commit[key])) {
+          return
+        }
+        commit[key].forEach((file) => {
+          files.add(file.replace(/\\/g, '/'))
+        })
+      })
+    })
+
+    return Array.from(files)
+  } catch (error) {
+    console.warn('Unable to read changed files from event payload:', error)
+    return []
+  }
+}
+
+/**
+ * Gets the before and head commit refs from GitHub environment variables.
+ * @returns {{beforeRef: string|undefined, headRef: string|undefined}} Commit references
+ */
+const getCommitRefs = () => {
+  const beforeRef = process.env.GITHUB_EVENT_BEFORE
+  const headRef = process.env.GITHUB_SHA
+
+  return { beforeRef, headRef }
+}
+
+/**
+ * Runs git diff to check if a directory has changes between two commits.
+ * @param {string} base - Base commit reference
+ * @param {string} target - Target commit reference
+ * @param {string} dir - Directory to check for changes
+ * @returns {{ok: boolean, changed?: boolean}} Result with ok status and changed flag
+ */
+const runGitDiff = (base, target, dir) => {
+  const result = spawnSync('git', ['diff', '--name-only', base, target, '--', dir], { encoding: 'utf8' })
+
+  if (result.error || result.status !== 0) {
+    return { ok: false }
+  }
+
+  return { ok: true, changed: result.stdout.trim().length > 0 }
+}
+
+/**
+ * Resolves the parent commit reference for a given commit.
+ * @param {string} ref - Commit reference
+ * @returns {string|undefined} Parent commit reference or undefined if not found
+ */
+const resolveParentRef = (ref) => {
+  if (!ref) {
+    return undefined
+  }
+
+  const result = spawnSync('git', ['rev-parse', '--verify', `${ref}^`], { encoding: 'utf8' })
+  if (result.error || result.status !== 0) {
+    return undefined
+  }
+
+  return result.stdout.trim()
+}
+
+/**
+ * Checks if a directory has changes using git diff or event payload.
+ * Uses event payload first, then falls back to git diff.
+ * @param {string} dir - Directory to check
+ * @param {string[]} changedFilesFromEvent - Changed files from event payload
+ * @param {string} beforeRef - Before commit reference
+ * @param {string} headRef - Head commit reference
+ * @returns {boolean} True if directory has changes
+ */
+const hasGitDiffChanges = (dir, changedFilesFromEvent, beforeRef, headRef) => {
+  const normalizedDir = dir.replace(/\\/g, '/')
+
+  if (changedFilesFromEvent.length > 0) {
+    return changedFilesFromEvent.some((file) => file === normalizedDir || file.startsWith(`${normalizedDir}/`))
+  }
+
+  const diffCandidates = []
+  if (beforeRef && headRef && !/^0+$/.test(beforeRef)) {
+    diffCandidates.push({ base: beforeRef, target: headRef })
+  }
+
+  const parentRef = resolveParentRef(headRef)
+  if (parentRef) {
+    diffCandidates.push({ base: parentRef, target: headRef })
+  }
+
+  for (const { base, target } of diffCandidates) {
+    const diffResult = runGitDiff(base, target, dir)
+    if (diffResult.ok) {
+      return diffResult.changed ?? true
+    }
+  }
+
+  return true
+}
+
+/**
+ * Wrapper to check if a scope directory has changes.
+ * @param {string} scopeDir - Scope directory path
+ * @param {string[]} changedFilesFromEvent - Changed files from event
+ * @param {string} beforeRef - Before commit ref
+ * @param {string} headRef - Head commit ref
+ * @returns {boolean} True if scope has changes
+ */
+const scopeHasChanges = (scopeDir, changedFilesFromEvent, beforeRef, headRef) =>
+  hasGitDiffChanges(scopeDir, changedFilesFromEvent, beforeRef, headRef)
+
+/**
+ * Builds the final matrix array with change detection and forced scopes.
+ * @param {Map} scopeMap - Discovered scopes
+ * @param {string[]} changedFilesFromEvent - Changed files from event
+ * @param {string} beforeRef - Before commit ref
+ * @param {string} headRef - Head commit ref
+ * @param {string[]} forcedShortNames - Short names to force into matrix
+ * @returns {Array<{name: string, shortName: string, dir: string, run: boolean}>} Matrix entries
+ */
+const buildMatrix = (scopeMap, changedFilesFromEvent, beforeRef, headRef, forcedShortNames) => {
+  const enriched = Array.from(scopeMap.values())
+    .map((scope) => ({
+      ...scope,
+      run: scopeHasChanges(scope.dir, changedFilesFromEvent, beforeRef, headRef),
+    }))
+    .sort((a, b) => a.name.localeCompare(b.name))
+
+  const forcedSet = new Set(forcedShortNames || [])
+  const base = enriched.filter((scope) => scope.run)
+  const forced = enriched.filter(
+    (scope) => forcedSet.has(scope.shortName) && !base.some((entry) => entry.shortName === scope.shortName),
+  )
+
+  return [...base, ...forced]
+}
+
+// Main execution
+const roots = loadRoots()
+const scopeMap = discoverScopes(roots)
+const changedFilesFromEvent = loadEventChangedFiles(process.env.GITHUB_EVENT_PATH)
+const { beforeRef, headRef } = getCommitRefs()
+const forcedShortNames = loadForcedShortNames()
+const matrix = buildMatrix(scopeMap, changedFilesFromEvent, beforeRef, headRef, forcedShortNames)
+
+setOutput('scopes', JSON.stringify(matrix))
+setOutput('scopes_count', String(matrix.length))

package/bin/templates/workspace/.github/actions/prepare-build-context/action.yml

@@ -0,0 +1,49 @@
+name: Prepare Build Context
+description: Flatten turbo prune output for Docker build
+
+inputs:
+  scope-short-name:
+    description: Short name of the scope (e.g., orders, storefront)
+    required: true
+  scope-dir:
+    description: Original scope directory (e.g., services/orders, apps/storefront)
+    required: true
+
+outputs:
+  context-dir:
+    description: Path to the prepared build context
+    value: ${{ steps.prepare.outputs.context-dir }}
+
+runs:
+  using: composite
+  steps:
+    - name: Prepare build context
+      id: prepare
+      shell: bash
+      run: |
+        set -euo pipefail
+        
+        CONTEXT_DIR="out/${{ inputs.scope-short-name }}/full"
+        SCOPE_DIR="${{ inputs.scope-dir }}"
+        
+        # Copy bun.lock from json folder
+        cp "out/${{ inputs.scope-short-name }}/json/bun.lock" "$CONTEXT_DIR/"
+        
+        # Flatten: move service/app files to root of contexti
+        if [ -d "$CONTEXT_DIR/$SCOPE_DIR" ]; then
+          # Copy all files and directories from the scope dir to context root
+          cp -r "$CONTEXT_DIR/$SCOPE_DIR"/. "$CONTEXT_DIR/"
+          
+          # Remove the nested scope dir
+          rm -rf "$CONTEXT_DIR/$SCOPE_DIR"
+        fi
+        
+        # Remove packages and apps/services dirs (dependencies come from registry)
+        rm -rf "$CONTEXT_DIR/packages" "$CONTEXT_DIR/apps" "$CONTEXT_DIR/services"
+        
+        # Clean up root package.json workspaces
+        cd "$CONTEXT_DIR"
+        jq 'del(.workspaces)' package.json > package.json.tmp
+        mv package.json.tmp package.json
+        
+        echo "context-dir=$CONTEXT_DIR" >> "$GITHUB_OUTPUT"

package/bin/templates/workspace/.github/actions/resolve-scope-tags/action.yml

@@ -0,0 +1,31 @@
+name: Resolve scope tags
+description: Determine checksum tags for deployable scopes, using downloaded metadata where available
+inputs:
+  markers-dir:
+    description: Directory containing downloaded change markers (default .artifacts)
+    required: false
+    default: .artifacts
+  scope-roots:
+    description: List of directories to scan for scopes (defaults to apps,services)
+    required: false
+  deployable-scopes:
+    description: Optional comma/space separated short-name list to restrict scope resolution
+    required: false
+  allow-missing-scopes:
+    description: Short names allowed to skip if no tag can be resolved
+    required: false
+  github-token:
+    description: GitHub token with read:packages scope to query GHCR
+    required: true
+  repository-owner:
+    description: Organization or user owning GHCR packages (defaults to repo owner)
+    required: false
+  repository-prefix:
+    description: Prefix for GHCR packages (defaults to $GHCR_REPOSITORY_PREFIX or "platform")
+    required: false
+outputs:
+  scope_image_tags:
+    description: JSON map of shortName -> checksum tag
+runs:
+  using: node20
+  main: index.js