chore: rename fundamentals to base (#9119)

packages/backend/server/src/base/event/def.ts

@@ -0,0 +1,60 @@
+import type { Snapshot, User, Workspace } from '@prisma/client';
+
+import { Flatten, Payload } from './types';
+
+export interface WorkspaceEvents {
+  team: {
+    seatAvailable: Payload<{ inviteId: string; email: string }[]>;
+    reviewRequest: Payload<{ inviteIds: string[] }>;
+    declineRequest: Payload<{
+      workspaceId: Workspace['id'];
+      inviteeId: User['id'];
+    }>;
+  };
+  deleted: Payload<Workspace['id']>;
+  blob: {
+    deleted: Payload<{
+      workspaceId: Workspace['id'];
+      key: string;
+    }>;
+  };
+}
+
+export interface DocEvents {
+  deleted: Payload<Pick<Snapshot, 'id' | 'workspaceId'>>;
+  updated: Payload<Pick<Snapshot, 'id' | 'workspaceId'>>;
+}
+
+export interface UserEvents {
+  updated: Payload<Omit<User, 'password'>>;
+  deleted: Payload<
+    User & {
+      ownedWorkspaces: Workspace['id'][];
+    }
+  >;
+}
+
+/**
+ * Event definitions can be extended by
+ *
+ * @example
+ *
+ * declare module './event/def' {
+ *   interface UserEvents {
+ *     created: Payload<User>;
+ *   }
+ * }
+ *
+ * assert<Event, 'user.created'>()
+ */
+export interface EventDefinitions {
+  workspace: WorkspaceEvents;
+  snapshot: DocEvents;
+  user: UserEvents;
+}
+
+export type EventKV = Flatten<EventDefinitions>;
+
+export type Event = keyof EventKV;
+export type EventPayload<E extends Event> = EventKV[E];
+export type { Payload };

packages/backend/server/src/base/event/index.ts

@@ -0,0 +1,43 @@
+import { Global, Injectable, Module } from '@nestjs/common';
+import {
+  EventEmitter2,
+  EventEmitterModule,
+  OnEvent as RawOnEvent,
+} from '@nestjs/event-emitter';
+
+import type { Event, EventPayload } from './def';
+
+@Injectable()
+export class EventEmitter {
+  constructor(private readonly emitter: EventEmitter2) {}
+
+  emit<E extends Event>(event: E, payload: EventPayload<E>) {
+    return this.emitter.emit(event, payload);
+  }
+
+  emitAsync<E extends Event>(event: E, payload: EventPayload<E>) {
+    return this.emitter.emitAsync(event, payload);
+  }
+
+  on<E extends Event>(event: E, handler: (payload: EventPayload<E>) => void) {
+    return this.emitter.on(event, handler);
+  }
+
+  once<E extends Event>(event: E, handler: (payload: EventPayload<E>) => void) {
+    return this.emitter.once(event, handler);
+  }
+}
+
+export const OnEvent = RawOnEvent as (
+  event: Event,
+  opts?: Parameters<typeof RawOnEvent>[1]
+) => MethodDecorator;
+
+@Global()
+@Module({
+  imports: [EventEmitterModule.forRoot()],
+  providers: [EventEmitter],
+  exports: [EventEmitter],
+})
+export class EventModule {}
+export { Event, EventPayload };

packages/backend/server/src/base/event/types.ts

@@ -0,0 +1,22 @@
+import type { Join, PathType } from '../utils/types';
+
+export type Payload<T> = {
+  __payload: true;
+  data: T;
+};
+
+export type Leaves<T, P extends string = ''> =
+  T extends Record<string, any>
+    ? {
+        [K in keyof T]: K extends string
+          ? T[K] extends Payload<any>
+            ? K
+            : Join<K, Leaves<T[K], P>>
+          : never;
+      }[keyof T]
+    : never;
+
+export type Flatten<T extends Record<string, any>> = {
+  // @ts-expect-error allow
+  [K in Leaves<T>]: PathType<T, K> extends Payload<infer U> ? U : never;
+};