Filter

Filter operations reduce the result set based on property values. TypeGraph provides whereNode() for filtering nodes and whereEdge() for filtering edges during traversals.

whereNode()

Filter nodes based on their properties:

const engineers = await store
  .query()
  .from("Person", "p")
  .whereNode("p", (p) => p.role.eq("Engineer"))
  .select((ctx) => ctx.p)
  .execute();

Parameters

.whereNode(alias, predicateFunction)

Parameter	Type	Description
alias	string	The node alias to filter (must exist in query)
predicateFunction	(accessor) => Predicate	Function that returns a predicate

The predicate function receives a typed accessor for the node’s properties.

whereEdge()

Filter based on edge properties during traversals:

const highPaying = await store
  .query()
  .from("Person", "p")
  .traverse("worksAt", "e")
  .whereEdge("e", (e) => e.salary.gte(100000))
  .to("Company", "c")
  .select((ctx) => ({
    person: ctx.p.name,
    company: ctx.c.name,
    salary: ctx.e.salary,
  }))
  .execute();

Parameters

.whereEdge(alias, predicateFunction)

Parameter	Type	Description
alias	string	The edge alias to filter (must exist in query)
predicateFunction	(accessor) => Predicate	Function that returns a predicate

Combining Predicates

AND

Both conditions must be true:

.whereNode("p", (p) =>
  p.status.eq("active").and(p.role.eq("admin"))
)

OR

Either condition can be true:

.whereNode("p", (p) =>
  p.role.eq("admin").or(p.role.eq("moderator"))
)

NOT

Negate a condition:

.whereNode("p", (p) =>
  p.status.eq("deleted").not()
)

Complex Combinations

Build complex logic with parenthetical grouping:

.whereNode("p", (p) =>
  p.status
    .eq("active")
    .and(p.role.eq("admin").or(p.role.eq("moderator")))
)

This evaluates as: status = 'active' AND (role = 'admin' OR role = 'moderator')

Multiple Filters

Chain multiple whereNode() calls for AND logic:

const activeManagers = await store
  .query()
  .from("Person", "p")
  .whereNode("p", (p) => p.status.eq("active"))
  .whereNode("p", (p) => p.role.eq("Manager"))
  .select((ctx) => ctx.p)
  .execute();

This is equivalent to:

.whereNode("p", (p) =>
  p.status.eq("active").and(p.role.eq("Manager"))
)

Filtering After Traversal

Filter nodes at any point in the query:

const techCompanyEngineers = await store
  .query()
  .from("Person", "p")
  .whereNode("p", (p) => p.role.eq("Engineer"))
  .traverse("worksAt", "e")
  .to("Company", "c")
  .whereNode("c", (c) => c.industry.eq("Technology"))
  .select((ctx) => ({
    person: ctx.p.name,
    company: ctx.c.name,
  }))
  .execute();

Common Predicates

Here are the most commonly used predicates. For complete reference, see Predicates.

Equality

p.name.eq("Alice")       // equals
p.name.neq("Bob")        // not equals

Comparison

p.age.gt(21)             // greater than
p.age.gte(21)            // greater than or equal
p.age.lt(65)             // less than
p.age.lte(65)            // less than or equal
p.age.between(18, 65)    // inclusive range

String Matching

p.name.contains("ali")   // substring match
p.name.startsWith("A")   // prefix match
p.name.endsWith("ice")   // suffix match
p.email.like("%@example.com")  // SQL LIKE pattern
p.name.ilike("alice")    // case-insensitive LIKE

Null Checks

p.deletedAt.isNull()     // is null/undefined
p.email.isNotNull()      // is not null

List Membership

p.status.in(["active", "pending"])
p.status.notIn(["archived", "deleted"])

Array Operations

p.tags.contains("typescript")
p.tags.containsAll(["typescript", "nodejs"])
p.tags.containsAny(["typescript", "rust", "go"])
p.tags.isEmpty()
p.tags.isNotEmpty()

Predicate Types by Field

The available predicates depend on the field type:

Field Type	Key Predicates
String	eq, contains, startsWith, like, ilike
Number	eq, gt, gte, lt, lte, between
Date	eq, gt, gte, lt, lte, between
Array	contains, containsAll, containsAny, isEmpty
Object	get(), hasKey, pathEquals
Embedding	similarTo()

See Predicates for complete documentation.

Count and Existence Helpers

Count Results

const count: number = await store
  .query()
  .from("Person", "p")
  .whereNode("p", (p) => p.status.eq("active"))
  .count();

Check Existence

const exists: boolean = await store
  .query()
  .from("Person", "p")
  .whereNode("p", (p) => p.email.eq("alice@example.com"))
  .exists();

Get First Result

const alice = await store
  .query()
  .from("Person", "p")
  .whereNode("p", (p) => p.email.eq("alice@example.com"))
  .select((ctx) => ctx.p)
  .first();

if (alice) {
  console.log(alice.name);
}

Next Steps

• Predicates - Complete predicate reference
• Traverse - Navigate relationships
• Advanced - Subqueries with exists() and inSubquery()