Power Sync Invoker

Execute advanced synchronization operations with parallel processing, transformation pipelines, and conditional sync rules for complex multi-system architectures.

When to Use This Command

Run this command when...

• You need to synchronize data across three or more systems simultaneously with dependency ordering and parallel execution
• Your sync requires data transformation during transit (e.g., schema migration, field renaming, format conversion)
• You want to invoke a parameterized sync pipeline with runtime arguments controlling scope, filters, and behavior

Avoid this command when...

• A simple two-system sync with default settings is sufficient (use Easy Sync Executor instead)
• You only need to check whether sync is healthy without actually running it (use Efficient Sync Health Monitor instead)

Quick Start

Copy
# .power-sync.yaml
pipeline:
  - name: github-to-staging
    source: github-api
    target: staging-db
    transform: normalize-fields
    parallel: true
  - name: staging-to-linear
    source: staging-db
    target: linear-api
    transform: enrich-metadata
    depends_on: github-to-staging
  - name: staging-to-slack
    source: staging-db
    target: slack-webhook
    transform: format-notification
    depends_on: github-to-staging

Copy
claude -p "Run the power sync pipeline from .power-sync.yaml with --scope=last-24h --team=backend"

Expected output:
Pipeline loaded: 3 stages, 2 parallel branches
Stage 1: github-to-staging [RUNNING]
  -> Fetched 142 items, transformed 142, loaded 142 (3.1s)
Stage 2a: staging-to-linear [RUNNING] (parallel)
  -> Enriched 142 items, dispatched 138, skipped 4 (2.4s)
Stage 2b: staging-to-slack [RUNNING] (parallel)
  -> Formatted 12 notifications, delivered 12 (0.8s)
Pipeline complete: 3/3 stages succeeded in 5.5s

Core Concepts

Concept	Description
Pipeline Stages	Ordered steps that execute sequentially or in parallel based on dependency declarations
Transform Layer	Pluggable data transformation applied between source extraction and target loading
Dependency Graph	DAG structure ensuring stages run only after their prerequisites complete
Scope Filters	Runtime arguments that narrow the sync to a time range, team, or label subset
Parallel Branches	Independent stages that execute concurrently when their shared dependency is satisfied

[GitHub API]
     |
     v
[github-to-staging] ----+
     |                   |
     v                   v
[staging-to-linear] [staging-to-slack]
     |                   |
     v                   v
  Linear             Slack Channel
  (138 issues)       (12 notifications)

Configuration

Parameter	Type	Default	Description	Example
pipeline	array	required	Ordered list of sync stages	See Quick Start
parallel	boolean	false	Run this stage in parallel with siblings	true
depends_on	string	none	Stage that must complete before this one starts	github-to-staging
transform	string	passthrough	Named transformation to apply during transit	normalize-fields
scope	string	all	Runtime filter for sync scope	last-24h

Best Practices

1. Design pipelines as DAGs -- Every stage should declare its dependencies explicitly so the engine can maximize parallel execution without race conditions.
2. Use a staging layer for multi-target syncs -- Extract once into a staging area, then fan out to multiple targets; this reduces API calls to the source system.
3. Keep transforms idempotent -- A transform applied twice to the same data should produce the same result, enabling safe pipeline retries.
4. Parameterize scope at runtime -- Hard-coding time ranges or team filters in the config reduces reusability. Use runtime arguments like --scope=last-24h.
5. Log per-stage metrics -- Capture item counts, durations, and error rates for each stage independently so bottlenecks are immediately visible.

Common Issues

1. Dependent stage starts before prerequisite completes -- The depends_on field name must exactly match the name of the prerequisite stage. Check for typos or case mismatches.
2. Transform errors cause entire pipeline to fail -- Add on_error: skip to non-critical stages so a single transformation failure does not halt downstream stages.
3. Parallel stages overwhelm target API rate limits -- When two parallel stages hit the same API, their combined request rate may exceed quotas. Add rate_limit: 10/s per stage to prevent throttling.