Determine Nodes in Network with PostgreSQL
Approach 1:
At first sight, it seems that I could apply a basic solution because, according to your sample data, each single connection is included in another connection.
SELECT 
    e1.node, 
    e1.connections, 
    COALESCE(e2.connections, e1.connections) nodes_in_chain
FROM
    example e1
LEFT JOIN 
    example e2
    ON e2.node &lt;&gt; e1.node
    AND e1.connections &lt;@ e2.connections;



node | connections | nodes_in_chain
:--- | :---------- | :-------------
a    | {a,b}       | {a,b,c,d}     
b    | {a,b,c,d}   | {a,b,c,d}     
c    | {b,c}       | {a,b,c,d}     
d    | {b,d}       | {a,b,c,d}     
e    | {e,f}       | {e,f}         
f    | {e,f}       | {e,f}         


Approach 2:
But, as @ypercube pointed out, this solution doesn't work if there are 3 or more linear points in a row.
Ex: e -&gt; f -&gt; g -&gt; h
As a reference to solve this question I used the answers in another related question:

Grouping on any one of multiple columns in Postgres

It uses a method called transitive closure to solve the problem.

Transitive closure
In mathematics, the transitive closure of a binary relation R on a set X is the smallest relation on X that contains R and is transitive.
For example, if X is a set of airports and xRy means &quot;there is a direct flight from airport x to airport y&quot; (for x and y in X), then the transitive closure of R on X is the relation R+ such that x R+ y means &quot;it is possible to fly from x to y in one or more flights&quot;. Informally, the transitive closure gives you the set of all places you can get to from any starting place.

First let me change your sample data by adding a linear connection of 4 nodes.
DELETE FROM example WHERE node = 'f';
INSERT INTO example VALUES
('f', ARRAY['e','f','g'],     null),
('g', ARRAY['f','g','h'],     null),
('h', ARRAY['g','h'],         null);

Now applying the math:
WITH RECURSIVE al (dst, src) AS --adjacent list or list of all related nodes
(
  SELECT e1.node, e2.node
  FROM   example e1
  JOIN   example e2
         ON e1.node = any(e2.connections)   
), tc (dst, src) AS
   (
     SELECT dst, src FROM al -- transitive closure
     UNION
     SELECT a1.dst, a2.src
     FROM   al as a1 
     JOIN   tc as a2 
            ON a1.src = a2.dst
   )
   SELECT   src, array_agg(DISTINCT dst ORDER BY dst) AS nodes_in_chain
   FROM     tc
   GROUP BY src;

Give us this result:
src | nodes_in_chain
:-- | :-------------
a   | {a,b,c,d}     
b   | {a,b,c,d}     
c   | {a,b,c,d}     
d   | {a,b,c,d}     
e   | {e,f,g,h}     
f   | {e,f,g,h}     
g   | {e,f,g,h}     
h   | {e,f,g,h}     

db&lt;&gt;fiddle here

NOTE: The original relation has only the immediate connections, which can be seen as paths of length 1 (2 nodes each). Approach 1 finds all paths of length 2 (3 nodes) as it applies a method of connecting once. To find paths of length N, you have to apply the methods N-1 times. To find all paths of arbitrary lengths (alas the transitive closure), you need a recursive solution, or a while loop.
It can't be done with simple SQL. (ie: one query without CTEs.)
@ypercube