code: func (adapter *Registry) PropagateResync(ctx context.Context, txData map[string]datasync.ChangeValue) error {
  	var events []func(done chan error)
  	adapter.lastRev.Cleanup()
  
  	for _, sub := range adapter.subscriptions {
  		items := map[string]datasync.KeyValIterator{}
  
  		for _, prefix := range sub.KeyPrefixes {
  			var kvs []datasync.KeyVal
  
  			for key, val := range txData {
  				if strings.HasPrefix(key, prefix) {
  					// TODO: call Put only once for each key (different subscriptions)
  					adapter.lastRev.PutWithRevision(key, val)
  
  					kvs = append(kvs, &KeyVal{
  						key:       key,
  						LazyValue: val,
  						rev:       val.GetRevision(),
  					})
  				}
  			}
  			items[prefix] = NewKVIterator(kvs)
  		}
  
  		sendTo := func(sub *Subscription) func(done chan error) {
  			return func(done chan error) {
  				sub.ResyncChan <- &ResyncEventDB{
  					ctx:         ctx,
  					its:         items,
  					DoneChannel: NewDoneChannel(done),
  				}
  			}
  		}
  		events = append(events, sendTo(sub))
  	}
  
  	done := make(chan error, 1)
  	go AggregateDone(events, done)
  
  	select {
  	case err := <-done:
  		if err != nil {
  			return err
  		}
  
  	// TODO: maybe higher timeout for resync event?
  	case <-time.After(PropagateChangesTimeout):
  		logrus.DefaultLogger().Warnf("Timeout of aggregated resync callbacks (%v)",
  			PropagateChangesTimeout)
  	}
  
  	return nil
  }
docs: // PropagateResync fills registered channels with the data.