Neo4j GraphQL

type Movie {
  title: String
  actors: [Actor!]!
    @relationship(type: "ACTED_IN", direction: IN, properties: "ActedIn")
}
 
type Actor {
  name: String
  movies: [Movie!]!
    @relationship(type: "ACTED_IN", direction: OUT, properties: "ActedIn")
}
 
interface ActedIn @relationshipProperties {
  roles: [String]
}

type User {
  id: ID! @id
  username: String!
}

type User {
  createdAt: DateTime! @timestamp(operations: [CREATE])
  updatedAt: DateTime! @timestamp(operations: [UPDATE])
 
  lastModified: DateTime! @timestamp
  # OR (these 2 are equivalent)
  lastModified: DateTime! @timestamp(operations: [CREATE, UPDATE])
}

type Product {
  name: String!
  slug: String! @populatedBy(callback: "slug", operations: [CREATE, UPDATE])
}

const slugCallback = async (root) => {
  return `${root.name}_slug`;
};
 
new Neo4jGraphQL({
  typeDefs,
  driver,
  features: {
    populatedBy: {
      callbacks: {
        slug: slugCallback,
      },
    },
  },
});

type Record {
    content: String!
    modifiedBy: @populatedBy(callback: "modifiedBy", operations: [CREATE, UPDATE])
}

const modifiedByCallback = async (_parent, _args, context) => {
  return context.username;
};
 
new Neo4jGraphQL({
  typeDefs,
  driver,
  features: {
    populatedBy: {
      callbacks: {
        modifiedBy: modifiedByCallback,
      },
    },
  },
});

query {
  Movie {
    title
    actors: ACTED_IN @this {
      role
      actor {
        name
      }
    }
    directors: DIRECTED @this {
      director {
        name
      }
    }
  }
}

interface Auth {
  isAuthenticated: boolean;
  roles?: string[];
  jwt: any;
}

type User {
  id: String
}
 
type Query {
  me: User
    @cypher(
      statement: """
      MATCH (user:User {id: $jwt.sub})
      RETURN user
      """
      columnName: "user"
    )
}

const server = new ApolloServer({
  typeDefs,
});
 
await startStandaloneServer(server, {
  context: async ({ req }) => {
    const userId = parseJwt(req.headers.authorization);
    return { cypherParams: { userId: userId } };
  },
});

type Query {
  userPosts: [Post]
    @cypher(
      statement: """
      MATCH (:User {id: $userId})-[:POSTED]->(p:Post)
      RETURN p
      """
      columnName: "p"
    )
}

type User {
  id: ID! @id @alias(property: "dbId")
  username: String!
}

type Colour {
  hexadecimal: String! @unique
}
 
type Colour {
  hexadecimal: String! @unique(constraintName: "unique_colour")
}

type Product
  @fulltext(indexes: [{ indexName: "ProductName", fields: ["name"] }]) {
  name: String!
  color: Color! @relationship(type: "OF_COLOR", direction: OUT)
}

CREATE FULLTEXT INDEX ProductName FOR (n:Product) ON EACH [n.name]

type Query {
  productsFulltextProductName(
    phrase: String!
    where: ProductFulltextWhere
    sort: [ProductFulltextSort!]
    limit: Int
    offset: Int
  ): [ProductFulltextResult!]!
}
 
"""
The result of a fulltext search on an index of Product
"""
type ProductFulltextResult {
  score: Float
  product: Product
}
 
"""
The input for filtering a fulltext query on an index of Product
"""
input ProductFulltextWhere {
  score: FloatWhere
  product: ProductWhere
}
 
"""
The input for sorting a fulltext query on an index of Product
"""
input ProductFulltextSort {
  score: SortDirection
  product: ProductSort
}
 
"""
The input for filtering the score of a fulltext search
"""
input FloatWhere {
  min: Float
  max: Float
}

query {
  productsFulltextProductName(
    phrase: "Hot sauce"
    where: { score: { min: 1.1 } }
    sort: [{ product: { name: ASC } }]
  ) {
    score
    product {
      name
    }
  }
}

directive @query(
  read: Boolean! = true
  aggregate: Boolean! = false
) on OBJECT | SCHEMA

type Movie @query(read: false, aggregate: true) {
  title: String
  length: Int
}

enum MutationFields {
  CREATE
  UPDATE
  DELETE
}
 
directive @mutation(
  operations: [MutationFields!]! = [CREATE, UPDATE, DELETE]
) on OBJECT | SCHEMA
 
# Enable only CREATE mutation
type Movie @mutation(operations: [CREATE]) {
  title: String
  length: Int
}

enum SubscriptionFields {
  CREATE
  UPDATE
  DELETE
  CREATE_RELATIONSHIP
  DELETE_RELATIONSHIP
}
 
directive @subscription(
  operations: [SubscriptionFields!]! = [
    CREATE
    UPDATE
    DELETE
    CREATE_RELATIONSHIP
    DELETE_RELATIONSHIP
  ]
) on OBJECT | SCHEMA
 
# Enable only movieCreated subscription for Movie
type Movie @subscription(operations: [CREATE]) {
  title: String
  length: Int
}

query {
  users(where: { age: { _lt: 50 } }) {
    id
    name
    age
  }
}

const features = {
  filters: {
    String: {
      LT: true,
      GT: true,
      LTE: true,
      GTE: true,
    },
  },
};
 
const neoSchema = new Neo4jGraphQL({ features, typeDefs, driver });

query {
  movies(options: { sort: [{ runtime: ASC }] }) {
    title
    runtime
  }
}

query {
  users(options: { offset: 10, limit: 10 }) {
    name
  }
}

type User
  @authentication(operations: [DELETE], jwt: { roles_INCLUDES: "admin" }) {
  id: ID!
  name: String!
  password: String!
}

type User {
  id: ID!
}
 
type Post
  @authorization(
    filter: [
      { where: { node: { author: { id: "$jwt.sub" } } } }
      {
        requireAuthentication: false
        operations: [READ]
        where: { node: { public: true } }
      }
    ]
  ) {
  title: String!
  content: String!
  public: Boolean!
  author: User! @relationship(type: "AUTHORED", direction: IN)
}

const ogm = new OGM({ typeDefs, driver });
const User = ogm.model("User");
const users = await User.find({
  where: { name_REGEX: regex },
  options: {
    offset,
    limit,
    sort,
  },
});

import type { CodegenConfig } from "@graphql-codegen/cli";
 
const config: CodegenConfig = {
  overwrite: true,
  schema: "http://localhost:3000/graphql",
  documents: "operations/**/*.gql",
  generates: {
    "src/gql/": {
      preset: "client",
      plugins: [],
    },
    "src/gql/req.ts": {
      plugins: [
        "typescript",
        "typescript-operations",
        "typescript-graphql-request",
      ],
      config: {
        rawRequest: true,
      },
    },
    "./graphql.schema.json": {
      plugins: ["introspection"],
    },
  },
};
 
export default config;