Implement notification queries for EdgeDB

Author: CarsonF

src/components/comments/mention-notification/comment-via-mention-notification.strategy.ts

@@ -1,5 +1,6 @@
 import { node, Query, relation } from 'cypher-query-builder';
 import { createRelationships, exp } from '~/core/database/query';
+import { e } from '~/core/edgedb';
 import {
   INotificationStrategy,
   InputOf,
@@ -18,6 +19,12 @@ export class CommentViaMentionNotificationStrategy extends INotificationStrategy
       );
   }
 
+  insertForEdgeDB(input: InputOf<Mentioned>) {
+    return e.insert(e.Notification.CommentMentioned, {
+      comment: e.cast(e.Comments.Comment, e.uuid(input.comment)),
+    });
+  }
+
   hydrateExtraForNeo4j(outVar: string) {
     return (query: Query) =>
       query
@@ -32,4 +39,10 @@ export class CommentViaMentionNotificationStrategy extends INotificationStrategy
           }).as(outVar),
         );
   }
+
+  hydrateExtraForEdgeDB() {
+    return e.is(e.Notification.CommentMentioned, {
+      comment: true,
+    });
+  }
 }

src/components/notification-system/system-notification.strategy.ts

@@ -1,4 +1,5 @@
 import { node, Query } from 'cypher-query-builder';
+import { e } from '~/core/edgedb';
 import { INotificationStrategy, NotificationStrategy } from '../notifications';
 import { SystemNotification } from './system-notification.dto';
 
@@ -8,4 +9,20 @@ export class SystemNotificationStrategy extends INotificationStrategy<SystemNoti
     return (query: Query) =>
       query.match(node('recipient', 'User')).return('recipient');
   }
+
+  recipientsForEdgeDB() {
+    return e.User; // all users
+  }
+
+  insertForEdgeDB(input: SystemNotification) {
+    return e.insert(e.Notification.System, {
+      message: input.message,
+    });
+  }
+
+  hydrateExtraForEdgeDB() {
+    return e.is(e.Notification.System, {
+      message: true,
+    });
+  }
 }

src/components/notifications/dto/notification.dto.ts

@@ -1,13 +1,19 @@
 import { Field, InterfaceType } from '@nestjs/graphql';
 import { DateTime } from 'luxon';
 import { keys as keysOf } from 'ts-transformer-keys';
-import { DateTimeField, Resource, SecuredProps } from '~/common';
+import {
+  DateTimeField,
+  resolveByTypename,
+  Resource,
+  SecuredProps,
+} from '~/common';
 import { e } from '~/core/edgedb';
 import { RegisterResource } from '~/core/resources';
 
 @RegisterResource({ db: e.default.Notification })
 @InterfaceType({
   implements: [Resource],
+  resolveType: resolveByTypename(Notification.name),
 })
 export class Notification extends Resource {
   static readonly Props: string[] = keysOf<Notification>();
@@ -18,6 +24,8 @@ export class Notification extends Resource {
   })
   readonly unread: boolean;
 
+  declare readonly __typename: string;
+
   @DateTimeField({
     nullable: true,
     description: 'When the notification was read for the requesting user',

src/components/notifications/notification.edgedb.repository.ts

@@ -0,0 +1,113 @@
+import { forwardRef, Inject, Injectable } from '@nestjs/common';
+import { Nil } from '@seedcompany/common';
+import { ID, PublicOf, ResourceShape } from '~/common';
+import { e, RepoFor, ScopeOf } from '~/core/edgedb';
+import {
+  MarkNotificationReadArgs,
+  Notification,
+  NotificationListInput,
+} from './dto';
+import { NotificationRepository as Neo4jRepository } from './notification.repository';
+import { NotificationServiceImpl } from './notification.service';
+
+@Injectable()
+export class NotificationRepository
+  extends RepoFor(Notification, {
+    hydrate: (notification) => ({
+      __typename: notification.__type__.name,
+      ...notification['*'],
+    }),
+    omit: ['create', 'update', 'list', 'readOne', 'readMany'],
+  })
+  implements PublicOf<Neo4jRepository>
+{
+  constructor(
+    @Inject(forwardRef(() => NotificationServiceImpl))
+    private readonly service: NotificationServiceImpl & {},
+  ) {
+    super();
+  }
+
+  onModuleInit() {
+    (this as any).hydrate = e.shape(e.Notification, (notification) => {
+      return Object.assign(
+        {
+          __typename: notification.__type__.name,
+        },
+        notification['*'],
+        ...[...this.service.strategyMap.values()].flatMap(
+          (strategy) => strategy.hydrateExtraForEdgeDB() ?? [],
+        ),
+      );
+    });
+  }
+
+  async create(
+    recipients: ReadonlyArray<ID<'User'>> | Nil,
+    type: ResourceShape<any>,
+    input: Record<string, any>,
+  ) {
+    const strategy = this.service.getStrategy(type);
+
+    const created = strategy.insertForEdgeDB(input);
+
+    const recipientsQuery = recipients
+      ? e.cast(e.User, e.cast(e.uuid, e.set(...recipients)))
+      : strategy.recipientsForEdgeDB(input);
+
+    const insertedRecipients = e.for(recipientsQuery, (user) =>
+      e.insert(e.Notification.Recipient, {
+        notification: created,
+        user: user,
+      }),
+    );
+
+    const query = e.select({
+      dto: e.select(created, this.hydrate),
+      totalRecipients: e.count(insertedRecipients),
+    });
+
+    return await this.db.run(query);
+  }
+
+  async markRead({ id, unread }: MarkNotificationReadArgs) {
+    const notification = e.cast(e.Notification, e.uuid(id));
+    const next = unread ? null : e.datetime_of_transaction();
+
+    const recipient = e.assert_exists(notification.currentRecipient);
+    const updated = e.update(recipient, () => ({
+      set: { readAt: next },
+    }));
+    const query = e.select(updated.notification, this.hydrate);
+    return await this.db.run(query);
+  }
+
+  async list(input: NotificationListInput) {
+    const myNotifications = e.select(e.Notification, (notification) => ({
+      filter: e.op(e.global.currentUser, 'in', notification.recipients.user),
+    }));
+
+    const paginated = this.paginate(myNotifications, input);
+
+    const myUnread = e.select(myNotifications, (notification) => ({
+      filter: e.op(notification.unread, '=', true),
+    }));
+
+    const query = e.select({
+      ...paginated,
+      items: e.select(paginated.items as typeof e.Notification, this.hydrate),
+      totalUnread: e.count(myUnread),
+    });
+
+    return await this.db.run(query);
+  }
+
+  protected listFilters(
+    notification: ScopeOf<typeof e.Notification>,
+    { filter }: NotificationListInput,
+  ) {
+    return [
+      filter?.unread != null && e.op(notification.unread, '=', filter.unread),
+    ];
+  }
+}

src/components/notifications/notification.module.ts

@@ -1,5 +1,7 @@
 import { Module } from '@nestjs/common';
-import { NotificationRepository } from './notification.repository';
+import { splitDb } from '~/core';
+import { NotificationRepository as EdgeDBRepository } from './notification.edgedb.repository';
+import { NotificationRepository as Neo4jRepository } from './notification.repository';
 import { NotificationResolver } from './notification.resolver';
 import {
   NotificationService,
@@ -11,7 +13,7 @@ import {
     NotificationResolver,
     { provide: NotificationService, useExisting: NotificationServiceImpl },
     NotificationServiceImpl,
-    NotificationRepository,
+    splitDb(Neo4jRepository, EdgeDBRepository),
   ],
   exports: [NotificationService],
 })

src/components/notifications/notification.strategy.ts

@@ -4,6 +4,7 @@ import { AbstractClass, Simplify } from 'type-fest';
 import type { UnwrapSecured } from '~/common';
 import type { RawChangeOf } from '~/core/database/changes';
 import type { QueryFragment } from '~/core/database/query-augmentation/apply';
+import { $, e } from '~/core/edgedb';
 import type { Notification } from './dto';
 
 export const NotificationStrategy = createMetadataDecorator({
@@ -26,15 +27,35 @@ export abstract class INotificationStrategy<
    */
   // eslint-disable-next-line @seedcompany/no-unused-vars
   recipientsForNeo4j(input: TInput) {
+    // No recipients. Only those explicitly specified in the service create call.
     return (query: Query) => query.unwind([], 'recipient').return('recipient');
   }
 
+  recipientsForEdgeDB(
+    // eslint-disable-next-line @seedcompany/no-unused-vars
+    input: TInput,
+  ): $.Expression<$.TypeSet<typeof e.User.__element__>> {
+    // No recipients. Only those explicitly specified in the service create call.
+    return e.cast(e.User, e.set());
+  }
+
   saveForNeo4j(input: TInput) {
     return (query: Query) => query.setValues({ node: input }, true);
   }
 
+  abstract insertForEdgeDB(
+    input: TInput,
+  ): $.Expression<
+    $.TypeSet<
+      $.ObjectType<string, typeof e.Notification.__element__.__pointers__>,
+      $.Cardinality.One
+    >
+  >;
+
   hydrateExtraForNeo4j(outVar: string): QueryFragment | undefined {
     const _used = outVar;
     return undefined;
   }
+
+  abstract hydrateExtraForEdgeDB(): Record<string, any>;
 }