Here's one way to do it using jq, a JSON-oriented command-line tool.

First, an outline of the steps:

1) Use arangoexport to export your author/subredit collection to a file, say, exported.json;

2) Run the jq script, nodes_and_edges.jq, shown below;

3) Use arangoimp to import the JSON produced in (2) into ArangoDB.

There are several ways the graph can be stored in ArangoDB, so ultimately you might wish to tweak nodes_and_edges.jq accordingly (e.g. to generate the nodes first, and then the edges).

INDEX

If your jq does not have INDEX defined, then use this:

def INDEX(stream; idx_expr):
  reduce stream as $row ({};
    .[$row|idx_expr|
      if type != "string" then tojson
      else .
      end] |= $row);
def INDEX(idx_expr): INDEX(.[]; idx_expr);

nodes_and_edges.jq

# This module is for generating JSON suitable for importing into ArangoDB.

### Generic Functions

# nodes/2
# $name must be the name of the ArangoDB collection of nodes corresponding to $key.
# The scheme for generating key names can be altered by changing the first
# argument of assign_keys, e.g. to "" if no prefix is wanted.
def nodes($key; $name):
  map( {($key): .[$key]} ) | assign_keys($name[0:1] + "_"; 1);

def assign_keys(prefix; start):
  . as $in
  | reduce range(0;length) as $i ([];
    . + [$in[$i] + {"_key": "\(prefix)\(start+$i)"}]);

# nodes_and_edges facilitates the normalization of an implicit graph
# in an ArangoDB "document" collection of objects having $from and $to keys.
# The input should be an array of JSON objects, as produced 
# by arangoexport for a single collection.
# If $nodesq is truthy, then the JSON for both the nodes and edges is emitted,
# otherwise only the JSON for the edges is emitted.
# 
# The first four arguments should be strings.
# 
# $from and $to should be the key names in . to be used for the from-to edges;
# $name1 and $name2 should be the names of the corresponding collections of nodes.
def nodes_and_edges($from; $to; $name1; $name2; $nodesq ):
  def dict($s): INDEX(.[$s]) | map_values(._key);
  def objects: to_entries[] | {($from): .key, "_key": .value};
  (nodes($from; $name1) | dict($from)) as $fdict
  | (nodes($to; $name2) | dict($to)  ) as $tdict
  | (if $nodesq then $fdict, $tdict | objects
     else empty end),
    (.[] | {_from: "\($name1)/\($fdict[.[$from]])",
            _to:   "\($name2)/\($tdict[.[$to]])"} )  ;


### Problem-Specific Functions

# If you wish to generate the collections separately,
# then these will come in handy:
def authors: nodes("author"; "authors");
def subredits: nodes("subredit"; "subredits");

def nodes_and_edges:
  nodes_and_edges("author"; "subredit"; "authors"; "subredits"; true);

nodes_and_edges

Invocation

jq -cf extract_nodes_edges.jq exported.json

This invocation will produce a set of JSONL (JSON-Lines) for "authors", one for "subredits" and an edge collection.

Example

[
  {"_id":"test/115159","_key":"115159","_rev":"_V8JSdTS---","author": "A", "subredit": "S1"},
  {"_id":"test/145120","_key":"145120","_rev":"_V8ONdZa---","author": "B", "subredit": "S2"},
  {"_id":"test/114474","_key":"114474","_rev":"_V8JZJJS---","author": "C", "subredit": "S3"}
]

Output

{"author":"A","_key":"name_1"}
{"author":"B","_key":"name_2"}
{"author":"C","_key":"name_3"}
{"subredit":"S1","_key":"sid_1"}
{"subredit":"S2","_key":"sid_2"}
{"subredit":"S3","_key":"sid_3"}
{"_from":"authors/name_1","_to":"subredits/sid_1"}
{"_from":"authors/name_2","_to":"subredits/sid_2"}
{"_from":"authors/name_3","_to":"subredits/sid_3"}

For a graph you need an edge collection for the edges and vertex collections for the nodes. You can't create a graph using only one collection.

Maybe this topic in the documentations is helpful for you.

Here's an AQL solution, which however presupposes that all the referenced collections already exist, and that UPSERT is not necessary.

FOR v IN testcollection
  LET a = v.author
  LET s = v.subredit
  FILTER a
  FILTER s
  LET fid = (INSERT {author: a}   INTO authors RETURN NEW._id)[0]
  LET tid = (INSERT {subredit: s} INTO subredits RETURN NEW._id)[0]
  INSERT {_from: fid, _to: tid} INTO author_of
  RETURN [fid, tid]