@crossdelta/platform-sdk 0.13.1 → 0.13.2

package/bin/templates/workspace/.github/actions/generate-scope-matrix/action.yml

@@ -1,17 +0,0 @@
-name: Generate scope matrix
-description: Discover Docker scopes and output JSON matrix entries for changed scopes
-inputs:
-  scope-roots:
-    description: Comma/space separated list of directories containing scope folders
-    required: false
-  force-scope-short-names:
-    description: Optional short-name list to force into the matrix even if unchanged
-    required: false
-outputs:
-  scopes:
-    description: JSON array describing scopes for the matrix strategy
-  scopes_count:
-    description: Number of scopes detected in the matrix
-runs:
-  using: node20
-  main: index.js

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

@@ -1,355 +0,0 @@
-/**
- * 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

@@ -1,49 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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