Comment maîtriser Neo4j avancé en 2026

docker run \
  --name neo4j-adv \
  --publish=7474:7474 --publish=7687:7687 \
  -p 7473:7473 \
  -v $HOME/neo4j/data:/data \
  -v $HOME/neo4j/logs:/logs \
  -v $HOME/neo4j/import:/import \
  -v $HOME/neo4j/plugins:/plugins \
  -v $HOME/neo4j/conf:/conf \
  -e NEO4J_AUTH=neo4j/Passw0rd2026 \
  -e NEO4J_PLUGINS='["graph-data-science","apoc"]' \
  -e NEO4J_dbms_memory_pagecache_size=2G \
  neo4j:5.21-enterprise

CREATE CONSTRAINT account_id IF NOT EXISTS FOR (a:Account) REQUIRE a.id IS UNIQUE;
CREATE CONSTRAINT user_id IF NOT EXISTS FOR (u:User) REQUIRE u.id IS UNIQUE;
CREATE CONSTRAINT transaction_id IF NOT EXISTS FOR (t:Transaction) REQUIRE t.id IS UNIQUE;

// Nœuds de base (100 comptes/users)
UNWIND range(1,100) AS i
CREATE (u:User {id: 'U'+i, name: 'User'+i, country: 'FR'})
CREATE (a:Account {id: 'A'+i, balance: rand()*10000, userId: 'U'+i});

// Transactions frauduleuses (liens suspects)
UNWIND [
  {from: 'A1', to: 'A50', amount: 50000, time: datetime()},
  {from: 'A50', to: 'A1', amount: 49900, time: datetime() + duration('PT1H')}
] AS tx
MATCH (from:Account {id: tx.from}), (to:Account {id: tx.to})
CREATE (t:Transaction {id: randomUUID(), amount: tx.amount, time: tx.time})
CREATE (from)-[:TRANSFERRED {amount: tx.amount}]->(t)-[:TO]->(to)
CREATE (u:User {id: 'Fraudster1', name: 'Suspect', country: 'XX'})-[:OWNS]->(a:Account {id: 'A50', balance: -1000});

// Trouver cycles frauduleux (profondeur 3)
MATCH path = (source:Account {id: 'A1'})-[:TRANSFERRED*1..3]->(target:Account)
WHERE source <> target AND ALL(r IN rels(path) | r.amount > 40000)
RETURN path, reduce(total=0.0, r IN rels(path) | total + r.amount) AS totalAmount
ORDER BY length(path) ASC
LIMIT 5;

// Shortest path avec poids
MATCH (start:Account {id:'A1'}), (end:Account {id:'A50'})
CALL gds.shortestPath.dijkstra.stream({
  sourceNode: start, targetNode: end,
  relationshipType: 'TRANSFERRED',
  relationshipWeightProperty: 'amount'
})
YIELD index, sourceNode, targetNode, totalCost, path
RETURN gds.util.asNode(sourceNode).id AS from,
       gds.util.asNode(targetNode).id AS to,
       totalCost, path
ORDER BY index;

// Indexes composites pour perf
CREATE INDEX account_balance IF NOT EXISTS FOR (a:Account) ON (a.balance, a.id);
CREATE INDEX transaction_time IF NOT EXISTS FOR (t:Transaction) ON (t.time);

// Projetter graphe GDS (in-mem)
CALL gds.graph.project(
  'fraudGraph',
  'Account',
  'TRANSFERRED',
  {relationshipProperties: 'amount'}
);

// Betweenness Centrality (fraud score)
CALL gds.betweenness.stream('fraudGraph', {
  maxIterations: 100,
  centralityRangeFrom: 0.9
})
YIELD nodeId, score
WHERE gds.util.asNode(nodeId).balance < 0
RETURN gds.util.asNode(nodeId).id AS account,
       score AS fraudScore
ORDER BY score DESC
LIMIT 10;

// Drop graph
CALL gds.graph.drop('fraudGraph');

import { Neo4j } from 'neo4j-driver';

const driver = Neo4j.driver(
  'bolt://localhost:7687',
  Neo4j.auth.basic('neo4j', 'Passw0rd2026')
);

const detectFraud = async () => {
  const session = driver.session({ database: 'neo4j' });
  try {
    const res = await session.executeRead(tx => tx.run(
      `MATCH (a1:Account {id: $id1})-[:TRANSFERRED*1..2]-(a2:Account)
       WHERE a2.balance < 0
       RETURN a1.id AS source, a2.id AS suspect, count(*) AS hops`,
      { id1: 'A1' }
    ));
    res.records.forEach(record => {
      console.log(`Fraud path: ${record.get('source')} -> ${record.get('suspect')} (${record.get('hops')} hops)`);
    });
  } catch (error) {
    console.error('Query failed:', error);
  } finally {
    await session.close();
  }
};

detectFraud().finally(() => driver.close());

// Bulk update avec APOC (path expansion)
MATCH (a:Account {id: 'A1'})-[:TRANSFERRED*]->(suspicious:Account {balance: -1000})
CALL apoc.do.case([
  length((a)-[:TRANSFERRED*]->(suspicious)) > 1, 'SET suspicious.riskScore = 0.95',
  suspicious.country <> 'FR', 'DETACH DELETE suspicious'
], '', {suspicious: suspicious, a: a}) YIELD value
RETURN value;