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

Fulltext Search

For nodes with at least one field declared with searchable(), use the node-level $fulltext.matches() for BM25-style ranked fulltext search. See Fulltext Search for the full guide.

d.$fulltext.matches("climate change", 20)  // Top 20 by relevance

d.$fulltext.matches("quarterly earnings", 10, {
  mode: "websearch",  // Google-style syntax
})

Combine with any other predicate — fulltext composes with metadata filters, graph traversal, and vector search:

d.$fulltext.matches("climate", 20)
  .and(d.tenantId.eq(tenant))
  .and(d.published.eq(true))

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
Nodes with searchable() fields	$fulltext.matches() (node-level, not per-field)
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()