Graph databases

import { Prorm, DataTypes } from 'ts-prorm-orm';

const prorm = new Prorm({
  dialect: 'neo4j',
  host: 'localhost', port: 7687,
  username: 'neo4j', password: process.env.NEO4J_PASSWORD!,
});
await prorm.connect();

const User = prorm.define('User', {
  name: { type: DataTypes.STRING(100) },
  age:  { type: DataTypes.INTEGER() },
});

import { Op } from 'ts-prorm-orm';

const adults = await User.findAll({
  where: { age: { [Op.gte]: 30 }, name: { [Op.ne]: 'Bob' } },
  order: [['age', 'DESC']],
  limit: 10,
});

MATCH (n:User)
WHERE (n.age >= $p0 AND n.name <> $p1)
RETURN n
ORDER BY n.age DESC
LIMIT 10
// params: { p0: 30, p1: 'Bob' }

query find($p0: int, $p1: string) {
  result(func: type(User), orderdesc: age, first: 10) @filter((ge(age, $p0) AND NOT eq(name, $p1))) {
    uid
    dgraph.type
    expand(_all_)
  }
}
# vars: { $p0: 30, $p1: 'Bob' }

User.hasMany(Post, { as: 'posts' });
await User.findAll({ include: [{ model: Post, as: 'posts' }] });

import { Neo4jGraphDialect } from 'ts-prorm-orm';

const g = prorm.getDialectInstance() as Neo4jGraphDialect;

// Ada follows user 7, with a property on the edge
await g.relate({
  fromLabel: 'User', fromWhere: { id: 42 },
  edgeLabel: 'FOLLOWS',
  toLabel: 'User', toWhere: { id: 7 },
  props: { since: 2024 },
});

// Active users within two FOLLOWS hops of Ada
const reachable = await g.traverse({
  label: 'User', where: { id: 42 },
  edgeLabel: 'FOLLOWS', direction: 'out',
  targetLabel: 'User', targetWhere: { active: true },
  minDepth: 1, maxDepth: 2,
  limit: 20,
});

// relate
MATCH (a:User) WHERE a.id = $p0
MATCH (b:User) WHERE b.id = $p1
MERGE (a)-[r:FOLLOWS]->(b)
SET r += $p2
RETURN r

// traverse
MATCH (n:User)
WHERE n.id = $p0
MATCH (n)-[:FOLLOWS*1..2]->(m:User)
WHERE m.active = $p1
RETURN DISTINCT m
LIMIT 20

# relate: a JSON mutation after resolving both ends by query
{ from(func: type(User)) @filter(eq(id, 42)) { uid } to(func: type(User)) @filter(eq(id, 7)) { uid } }

# traverse
query traverse($p0: int, $p1: bool) {
  result(func: type(User), first: 20) @filter(eq(id, $p0)) {
    uid
    FOLLOWS @filter(eq(active, $p1)) {
      uid
      expand(_all_)
    }
  }
}

const g = prorm.getDialectInstance()!;
g.compileCreateIndex('User', ['email'], 'idx_email');
// CREATE INDEX idx_email IF NOT EXISTS FOR (n:User) ON (n.email)

"materialized views" is not supported by the neo4j graph dialect

import { GraphCapabilityError } from 'ts-prorm-orm';

try {
  await prorm.createMaterializedView({ name: 'x', query: '…' });
} catch (e) {
  if (e instanceof GraphCapabilityError) { /* pick another approach */ }
}

const { rows } = await prorm.query(`
  MATCH path = shortestPath((a:User {id: $from})-[:FOLLOWS*..6]-(b:User {id: $to}))
  RETURN length(path) AS hops
`, { replacements: { from, to } });