Neo4j Infrastructure

type Entity @node {
  id: ID! @id
  name: String!
  description: String
  status: String! @default(value: "draft")
  # Uniqueness enforced via DB constraints (see migrations/)

  # Relationships
  parent: Parent! @relationship(type: "BELONGS_TO", direction: OUT)
  children: [Child!]! @relationship(type: "HAS", direction: OUT)

  # Computed (needs custom resolver)
  computed: Boolean @customResolver

  # Timestamps
  createdAt: DateTime! @timestamp(operations: [CREATE])
  updatedAt: DateTime! @timestamp(operations: [CREATE, UPDATE])
}

organisation: Organisation! @relationship(type: "FOR", direction: OUT)

type UserAccountEdge @relationshipProperties {
  role: String!
  joinedAt: DateTime!
}

type Account @node {
  users: [User!]! @relationship(type: "MEMBER_OF", direction: IN, properties: "UserAccountEdge")
}

# Both sides reference the same relationship type
frameworks: [Framework!]! @relationship(type: "USES", direction: OUT)
engagements: [Engagement!]! @relationship(type: "USES", direction: IN)

import { getDriver } from '../client';

export const organisationResolvers = {
  Organisation: {
    provisional: async (parent: { id: string }) => {
      const driver = getDriver();
      const session = driver.session();
      try {
        const result = await session.run(
          `MATCH (o:Organisation {id: $id}) RETURN o:Provisional as provisional`,
          { id: parent.id }
        );
        return result.records[0]?.get('provisional') ?? false;
      } finally {
        await session.close();
      }
    },
  },
};

import { executeCypher } from '../neo4j/cypher-executor';

// Read query
const result = await executeCypher(
  `MATCH (o:Organisation)-[:HAS]->(l:Location) WHERE o.id = $id RETURN l`,
  { id: organisationId },
  { accessMode: 'READ' }
);

// Write query
await executeCypher(
  `MATCH (o:Organisation {id: $id}) SET o.name = $name RETURN o`,
  { id, name },
  { accessMode: 'WRITE' }
);

pnpm codegen  # Regenerate types