       sourceId : @getId()
     }, { limit, sort: { '_id' : -1 } }, (err, rels) ->
       accounts = []
-      daisy queue = rels.map (r) ->
-        ->
+      queue = rels.map (r) ->
+        (next) ->
           JAccount = require './account'
           JAccount.one { _id: r.targetId }, (err, acc) ->
             accounts.push acc  if not err and acc
-            queue.next()
-
-      queue.push -> callback null, accounts
+            next()
+
+      async.series queue, -> callback null, accounts
 
   follow: secure (client, options, callback) ->
     [callback, options] = [options, callback] unless callback

            when 'deleted' then deletedTags.push tag.title
            when 'synonym'
              childTag = tag
              synonyms.push ->
                childTag.fetchSynonym (err, synonym) ->
                  if not err and synonym?
                    resultMap[synonym.getId()] ?= synonym
                    parentTag = resultMap[synonym.getId()]
                    parentTag.children ?= []
                    parentTag.children.push childTag.title
                  synonyms.fin()
            else resultMap[tag.getId()] = tag

        dash synonyms, ->
          result = []
          result.push val for key, val of resultMap
          callback null, { tags: result, deletedTags }

        unless childTopicRels?.length then @delete_ callback
        else
          queue = childTopicRels.map (childTopicRel) ->
            (fin) -> JTag.one { '_id': childTopicRel.sourceId }, (err, childTopic) ->
              return fin err if err
              return fin new KodingError 'Child Topic could not be found' unless childTopic
              childTopic.delete_ (err) ->
                return fin err if err
                Relationship.remove { sourceId: childTopic.getId(), as: 'synonymOf' }, -> fin()

          async.parallel queue, (err) =>
            return callback err  if err
            @delete_ callback


  @fetchSkillTags:(selector, options, callback) ->
