Hier is een voorbeeld van een geavanceerd GraphQL-schema dat multi-context data modellering ondersteunt voor een sociaal mediaplatform met verschillende gebruikersrollen en contentmoderatie. Het schema maakt gebruik van context-specifieke velden en toegangscontroles, en is ontworpen voor schaalbaarheid en onderhoudbaarheid. ### Kernprincipes: - **Gebruik van interfaces en union types**: voor gedeelde en variabele data. - **Context-specifieke velden**: door middel van directives of conditional resolvers. - **Rolgebaseerde toegangscontrole**: via schema-annotaties of middleware. - **Flexibel ontwerp**: door scheiding van content, gebruikersrollen en moderatie. --- ### Voorbeeldschema ```graphql # Gebruikersrollen enum Role { ADMIN MODERATOR USER GUEST } # Content status enum ContentStatus { PUBLISHED PENDING_REVIEW REJECTED } # Content type met context-specifieke velden type Post { id: ID! title: String! body: String! author: User! createdAt: String! # Velden die zichtbaar zijn voor alle rollen status: ContentStatus! # Velden zichtbaar voor moderators en admins moderationNotes: String @auth(roles: [MODERATOR, ADMIN]) # Velden die alleen voor admins zichtbaar zijn internalMetadata: String @auth(roles: [ADMIN]) # Velden die afhankelijk zijn van de context comments: [Comment!]! } # User type type User { id: ID! username: String! email: String! @auth(roles: [ADMIN, MODERATOR]) # alleen zichtbaar voor admins en moderators role: Role! profile: UserProfile } type UserProfile { avatarUrl: String bio: String # Velden die zichtbaar zijn voor de gebruiker zelf of moderators privateData: String @auth(roles: [MODERATOR, USER]) } # Comment type type Comment { id: ID! content: String! author: User! createdAt: String! # Moderatie velden flagged: Boolean moderationNotes: String @auth(roles: [MODERATOR, ADMIN]) } # Query type met context-gevoelige data type Query { posts(filter: PostFilter): [Post!]! user(id: ID!): User } # Filters kunnen context-gevoelig zijn input PostFilter { status: ContentStatus authorId: ID } # Mutaties met rolgebaseerde toegangscontrole type Mutation { createPost(input: CreatePostInput!): Post @auth(roles: [USER, ADMIN, MODERATOR]) updatePost(id: ID!, input: UpdatePostInput!): Post @auth(roles: [ADMIN, MODERATOR]) deletePost(id: ID!): Boolean @auth(roles: [ADMIN]) moderatePost(id: ID!, action: ModerateAction!): Post @auth(roles: [MODERATOR, ADMIN]) } input CreatePostInput { title: String! body: String! } input UpdatePostInput { title: String body: String status: ContentStatus } enum ModerateAction { APPROVE REJECT REQUEST_CHANGES } ``` --- ### Toelichting en flexibiliteit 1. **Role-gebaseerde velden**: Velden zoals `email`, `internalMetadata`, en `moderationNotes` worden alleen getoond als de gebruiker de juiste rol heeft, door middel van een aangepaste directive `@auth`. Dit maakt het mogelijk om op schema-niveau zichtbaarheid te regelen afhankelijk van de context (bijvoorbeeld, de ingelogde gebruiker). 2. **Context-specifieke resolvers**: De serverimplementatie kan de resolvers aanpassen op basis van de context (bijvoorbeeld, de ingelogde gebruiker en zijn rol) om te bepalen welke velden en data worden getoond. 3. **Gescheiden data modellen**: Door gebruik te maken van union types en interfaces kunnen verschillende content types en moderatie-werelden worden uitgebreid zonder het hele schema te herschrijven. 4. **Schaalbaarheid en onderhoudbaarheid**: Dit schema maakt het mogelijk om nieuwe rollen, velden of content types toe te voegen door gewoon nieuwe velden of types te definiëren, zonder de bestaande structuur te verstoren. 5. **Middleware en directives**: De `@auth` directive is een voorbeeld van hoe je access control kan integreren in het schema. Je kunt deze implementeren met schema-directives en resolvers die controleren op de gebruikersrol. --- ### Samenvatting Door gebruik te maken van role- en context-gevoelige velden, directives en gescheiden modellen, biedt dit schema een schaalbare en onderhoudbare basis voor multi-rol en multi-context data modellering binnen één API. Het ondersteunt dynamisch zichtbaarheid en toegangscontrole, essentieel voor een platform met diverse gebruikers en contentmoderatie. Heeft u specifieke wensen voor bijvoorbeeld real-time updates, meer geavanceerde moderatie workflows, of andere contexten?

Zeker, ik help je graag met een geavanceerd GraphQL-schema voor een sociaal media platform met multi-context ondersteuning. Hieronder vind je een uitgebreide implementatie. ## Schema Definitie ```graphql # Basis types en interfaces interface Node { id: ID! } interface Timestamps { createdAt: DateTime! updatedAt: DateTime! } enum UserRole { ADMIN MODERATOR CONTENT_CREATOR STANDARD_USER GUEST } enum ContentStatus { DRAFT PUBLISHED FLAGGED REMOVED UNDER_REVIEW } # Context type voor autorisatie type AuthContext { userId: ID role: UserRole! permissions: [String!]! } # Gebruiker type met rol-gebaseerde velden type User implements Node & Timestamps { id: ID! username: String! email: String! @visible(roles: [ADMIN, MODERATOR]) profile: UserProfile! role: UserRole! @visible(roles: [ADMIN, MODERATOR]) status: UserStatus! @visible(roles: [ADMIN, MODERATOR]) lastLogin: DateTime @visible(roles: [ADMIN]) createdAt: DateTime! updatedAt: DateTime! # Rol-gebaseerde relaties posts: [Post!]! moderatedContent: [Post!]! @visible(roles: [ADMIN, MODERATOR]) moderationHistory: [ModerationAction!]! @visible(roles: [ADMIN, MODERATOR]) } type UserProfile { displayName: String! bio: String avatar: String location: String website: String isPublic: Boolean! # Alleen zichtbaar voor admins of de gebruiker zelf privateEmail: String @visible(roles: [ADMIN]) birthDate: DateTime @visible(roles: [ADMIN, USER_SELF]) } # Content types met moderatie-ondersteuning type Post implements Node & Timestamps { id: ID! title: String! content: String! author: User! status: ContentStatus! visibility: ContentVisibility! # Moderatie-gerelateerde velden flags: [Flag!]! @visible(roles: [ADMIN, MODERATOR]) moderationHistory: [ModerationAction!]! @visible(roles: [ADMIN, MODERATOR]) removalReason: String @visible(roles: [ADMIN, MODERATOR]) # Metadata likes: Int! comments: [Comment!]! tags: [String!]! # Gevoelige statistieken viewCount: Int! @visible(roles: [ADMIN, MODERATOR, CONTENT_CREATOR]) engagementRate: Float! @visible(roles: [ADMIN, MODERATOR]) } type Comment implements Node & Timestamps { id: ID! content: String! author: User! post: Post! parentComment: Comment status: ContentStatus! # Moderatie velden flags: [Flag!]! @visible(roles: [ADMIN, MODERATOR]) removalReason: String @visible(roles: [ADMIN, MODERATOR]) } # Moderatie systeem type ModerationAction implements Node & Timestamps { id: ID! moderator: User! target: ModerationTarget! action: ModerationActionType! reason: String! notes: String @visible(roles: [ADMIN]) duration: Int # Voor tijdelijke acties } type Flag { id: ID! reporter: User! reason: String! severity: FlagSeverity! createdAt: DateTime! } # Input types voor mutaties input CreatePostInput { title: String! content: String! tags: [String!] visibility: ContentVisibility! } input ModerationInput { targetId: ID! action: ModerationActionType! reason: String! notes: String duration: Int } # Enums enum ModerationActionType { REMOVE_CONTENT RESTORE_CONTENT SUSPEND_USER WARN_USER FLAG_CONTENT } enum FlagSeverity { LOW MEDIUM HIGH CRITICAL } enum ContentVisibility { PUBLIC PRIVATE FOLLOWERS_ONLY UNLISTED } # Query type met context-aware resolvers type Query { # Publieke queries posts( first: Int = 20 after: String tags: [String!] sortBy: PostSort = NEWEST ): PostConnection! post(id: ID!): Post user(username: String!): User searchPosts(query: String!): [Post!]! # Beheerder/moderator queries moderationQueue: [Post!]! @auth(roles: [ADMIN, MODERATOR]) flaggedContent: [Post!]! @auth(roles: [ADMIN, MODERATOR]) userAnalytics(userId: ID!): UserAnalytics! @auth(roles: [ADMIN, MODERATOR]) # Systeem queries systemHealth: SystemHealth! @auth(roles: [ADMIN]) } # Mutatie type met autorisatie type Mutation { # Content mutaties createPost(input: CreatePostInput!): Post! @auth updatePost(id: ID!, input: UpdatePostInput!): Post! @auth deletePost(id: ID!): Boolean! @auth # Moderatie mutaties flagContent(targetId: ID!, reason: String!): Boolean! @auth moderateContent(input: ModerationInput!): ModerationAction! @auth(roles: [ADMIN, MODERATOR]) # Gebruiker beheer updateUserRole(userId: ID!, role: UserRole!): User! @auth(roles: [ADMIN]) suspendUser(userId: ID!, duration: Int, reason: String!): Boolean! @auth(roles: [ADMIN, MODERATOR]) } # Geavanceerde types voor schaalbaarheid type PostConnection { edges: [PostEdge!]! pageInfo: PageInfo! totalCount: Int! moderationCount: Int! @visible(roles: [ADMIN, MODERATOR]) } type PostEdge { node: Post! cursor: String! } type PageInfo { hasNextPage: Boolean! hasPreviousPage: Boolean! startCursor: String endCursor: String } type UserAnalytics { userId: ID! postCount: Int! totalViews: Int! engagementRate: Float! moderationScore: Float! recentFlags: Int! } type SystemHealth { databaseStatus: String! cacheStatus: String! activeUsers: Int! moderationQueueSize: Int! } ``` ## Implementatie Strategieën ### 1. Context Management ```graphql # Directives voor autorisatie directive @auth(roles: [UserRole]) on FIELD_DEFINITION directive @visible(roles: [UserRole]) on FIELD_DEFINITION # Context wrapper in resolvers type Context { auth: AuthContext! requestId: String! timestamp: DateTime! } ``` ### 2. Field-level Security Implementeer field-level security met custom directives: ```javascript // Voorbeeld implementatie in Apollo Server const authDirective = new SchemaDirectiveVisitor({ visitFieldDefinition(field) { const { resolve = defaultFieldResolver } = field; field.resolve = async function (source, args, context, info) { // Valideer autorisatie op basis van context const requiredRoles = getRolesFromDirective(field); if (!hasRequiredRole(context.auth, requiredRoles)) { throw new ForbiddenError('Onvoldoende rechten'); } return resolve.call(this, source, args, context, info); }; } }); ``` ### 3. DataLoader Pattern voor Performance ```javascript // Gebruik DataLoaders voor N+1 query probleem const createLoaders = () => ({ user: new DataLoader(keys => batchGetUsers(keys)), post: new DataLoader(keys => batchGetPosts(keys)), moderationActions: new DataLoader(keys => batchGetModerationActions(keys)) }); ``` ## Schaalbaarheidskenmerken ### 1. Modular Schema Design ```graphql # Split schema in modules extend type Query { admin: AdminQueries! @auth(roles: [ADMIN]) moderation: ModerationQueries! @auth(roles: [ADMIN, MODERATOR]) } type AdminQueries { systemMetrics: SystemMetrics! userManagement: UserManagement! } type ModerationQueries { queue: ModerationQueue! reports: ModerationReports! } ``` ### 2. Federation Support ```graphql # Voor microservices architectuur extend type User @key(fields: "id") { id: ID! @external moderatedContent: [Post!]! } extend type Post @key(fields: "id") { id: ID! @external moderationHistory: [ModerationAction!]! } ``` ## Best Practices voor Onderhoud 1. **Schema Validation Rules**: - Gebruik linters voor consistentie - Documenteer alle types met descriptions - Versioneer schema changes 2. **Performance Monitoring**: - Query complexity analysis - Depth limiting - Query caching strategies 3. **Error Handling**: - Uniform error responses - Field-level error handling - Contextuele error messages Dit schema biedt: - **Flexibiliteit**: Rol-gebaseerde toegang op veld- en type-niveau - **Schaalbaarheid**: Ondersteuning voor federation en modular design - **Onderhoudbaarheid**: Duidelijke scheiding van concerns - **Uitbreidbaarheid**: Eenvoudig nieuwe contexten toe te voegen Het gebruikt GraphQL's sterke punten voor type-veiligheid en introspectie terwijl het complexe autorisatie-logica elegant afhandelt via directives en context management.