Class Neo4jStore

constructor

• new Neo4jStore(options: Neo4jStoreOptions): Neo4jStore

  Parameters

  • options: Neo4jStoreOptions

  Returns Neo4jStore

Readonlyname

Readonlylibrary

connect

• connect(): Promise<void>

  Returns Promise<void>

disconnect

• disconnect(): Promise<void>

  Returns Promise<void>

isConnected

• isConnected(): boolean

  Returns boolean

getClient

• getClient(): Driver

  Returns the underlying neo4j-driver Driver for anything not wrapped here.

  Returns Driver

session

• session(options?: Neo4jSessionOptions): Session

  Open a new Session. Sessions are lightweight and disposable - open one per logical unit of work and close it when done (run(), executeRead()/executeWrite(), and beginTransaction() all do this for you; call this directly only if you need the raw Session, e.g. for session.run()'s streaming subscribe() API).

  Parameters

  • options: Neo4jSessionOptions = {}

  Returns Session

run

• run<T = Record<string, unknown>>(
      cypher: string,
      params?: CypherParams,
      options?: Neo4jSessionOptions,
  ): Promise<CypherResult<T>>

  Run a single parameterized Cypher statement as an auto-commit query, on a session opened and closed for just this call. Always parameterize user-supplied values ($name, not string concatenation) - the driver sends params separately from the query text, the same protection bind parameters give you against SQL injection.

  Type Parameters

  • T = Record<string, unknown>

  Parameters

  • cypher: string
  • params: CypherParams = {}
  • options: Neo4jSessionOptions = {}

  Returns Promise<CypherResult<T>>

executeRead

• executeRead<T>(
      work: (tx: ManagedTransaction) => T | Promise<T>,
      options?: Neo4jSessionOptions,
  ): Promise<T>

  Run work inside a managed read transaction. The driver automatically retries work on transient errors (e.g. deadlocks, leader switches in a cluster) - work may run more than once, so it must be idempotent and side-effect-free outside of the transaction it's given.

  Type Parameters

  • T

  Parameters

  • work: (tx: ManagedTransaction) => T | Promise<T>
  • options: Neo4jSessionOptions = {}

  Returns Promise<T>

executeWrite

• executeWrite<T>(
      work: (tx: ManagedTransaction) => T | Promise<T>,
      options?: Neo4jSessionOptions,
  ): Promise<T>

  Like executeRead(), but for a managed write transaction (defaultAccessMode: 'WRITE').

  Type Parameters

  • T

  Parameters

  • work: (tx: ManagedTransaction) => T | Promise<T>
  • options: Neo4jSessionOptions = {}

  Returns Promise<T>

beginTransaction

• beginTransaction(options?: Neo4jSessionOptions): Promise<Neo4jTransaction>

  Begin an explicit transaction spanning multiple run() calls, on a session held open until commit()/rollback(). Unlike executeRead()/executeWrite(), this is never retried automatically

  • use it when you need multiple round trips with logic in between, or full manual control over commit/rollback.

  Parameters

  • options: Neo4jSessionOptions = {}

  Returns Promise<Neo4jTransaction>

createNode

• createNode<P extends Record<string, unknown> = Record<string, unknown>>(
      labels: string | string[],
      properties?: P,
  ): Promise<GraphNode<P>>

  CREATE (n:Label1:Label2) SET n = $properties RETURN n

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • labels: string | string[]
  • properties: P = ...

  Returns Promise<GraphNode<P>>

getNodeByElementId

• getNodeByElementId<P extends Record<string, unknown> = Record<string, unknown>>(
      elementId: string,
  ): Promise<GraphNode<P> | null>

  MATCH (n) WHERE elementId(n) = $elementId RETURN n

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • elementId: string

  Returns Promise<GraphNode<P> | null>

findNodes

• findNodes<P extends Record<string, unknown> = Record<string, unknown>>(
      labels?: string | string[],
      where?: Record<string, unknown>,
      options?: Neo4jFindOptions,
  ): Promise<GraphNode<P>[]>

  MATCH (n:Label) WHERE n.k1 = $k1 AND ... RETURN n [SKIP $skip] [LIMIT $limit]

  where is an equality-only match on node properties (no operators, ranges, or OR) - use run() directly for anything more expressive.

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • labels: string | string[] = []
  • where: Record<string, unknown> = {}
  • options: Neo4jFindOptions = {}

  Returns Promise<GraphNode<P>[]>

updateNode

• updateNode<P extends Record<string, unknown> = Record<string, unknown>>(
      elementId: string,
      properties: Partial<P>,
  ): Promise<GraphNode<P> | null>

  MATCH (n) WHERE elementId(n) = $elementId SET n += $properties RETURN n (merges, does not replace, existing properties)

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • elementId: string
  • properties: Partial<P>

  Returns Promise<GraphNode<P> | null>

deleteNode

• deleteNode(elementId: string, options?: DeleteNodeOptions): Promise<boolean>

  MATCH (n) WHERE elementId(n) = $elementId [DETACH] DELETE n

  Without options.detach, deleting a node that still has relationships fails (Neo4j refuses to leave dangling relationships) - the underlying error surfaces as a DatabaseError. Returns whether a node was actually deleted (based on the query's nodesDeleted counter).

  Parameters

  • elementId: string
  • options: DeleteNodeOptions = {}

  Returns Promise<boolean>

countNodes

• countNodes(
      labels?: string | string[],
      where?: Record<string, unknown>,
  ): Promise<number>

  MATCH (n:Label) WHERE ... RETURN count(n) AS count

  Parameters

  • labels: string | string[] = []
  • where: Record<string, unknown> = {}

  Returns Promise<number>

createRelationship

• createRelationship<P extends Record<string, unknown> = Record<string, unknown>>(
      fromElementId: string,
      toElementId: string,
      type: string,
      properties?: P,
  ): Promise<GraphRelationship<P>>

  MATCH (a), (b) WHERE elementId(a) = $fromElementId AND elementId(b) = $toElementId CREATE (a)-[r:TYPE]->(b) SET r = $properties RETURN r

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • fromElementId: string
  • toElementId: string
  • type: string
  • properties: P = ...

  Returns Promise<GraphRelationship<P>>

getRelationshipByElementId

• getRelationshipByElementId<
      P extends Record<string, unknown> = Record<string, unknown>,
  >(
      elementId: string,
  ): Promise<GraphRelationship<P> | null>

  MATCH ()-[r]->() WHERE elementId(r) = $elementId RETURN r

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • elementId: string

  Returns Promise<GraphRelationship<P> | null>

findRelationships

• findRelationships<P extends Record<string, unknown> = Record<string, unknown>>(
      type?: string,
      where?: Record<string, unknown>,
      options?: Neo4jFindOptions,
  ): Promise<GraphRelationship<P>[]>

  MATCH (a)-[r:TYPE]->(b) WHERE r.k1 = $k1 AND ... RETURN r [SKIP $skip] [LIMIT $limit]

  Omit type to match relationships of any type.

  Type Parameters

  • P extends Record<string, unknown> = Record<string, unknown>

  Parameters

  • Optionaltype: string
  • where: Record<string, unknown> = {}
  • options: Neo4jFindOptions = {}

  Returns Promise<GraphRelationship<P>[]>

deleteRelationship

• deleteRelationship(elementId: string): Promise<boolean>

  MATCH (a)-[r]->(b) WHERE elementId(r) = $elementId DELETE r - returns whether a relationship was actually deleted.

  Parameters

  • elementId: string

  Returns Promise<boolean>