feat: Dynamic hook registration for WorkspaceQueryHooks

packages/twenty-server/src/engine/api/graphql/graphql-config/graphql-config.service.ts

@@ -141,8 +141,10 @@ export class GraphQLConfigService
     // Create a new contextId for each request
     const contextId = ContextIdFactory.create();
 
-    // Register the request in the contextId
-    this.moduleRef.registerRequestByContextId(context.req, contextId);
+    if (this.moduleRef.registerRequestByContextId) {
+      // Register the request in the contextId
+      this.moduleRef.registerRequestByContextId(context.req, contextId);
+    }
 
     // Resolve the WorkspaceSchemaFactory for the contextId
     const workspaceFactory = await this.moduleRef.resolve(

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/decorators/workspace-query-hook.decorator.ts

@@ -0,0 +1,40 @@
+import { Scope, SetMetadata } from '@nestjs/common';
+import { SCOPE_OPTIONS_METADATA } from '@nestjs/common/constants';
+
+import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-query-hook.type';
+import { WorkspaceResolverBuilderMethodNames } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
+
+import { HOOK_METADATA } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/workspace-query-hook.constants';
+
+export type WorkspaceQueryHookKey =
+  `${string}.${WorkspaceResolverBuilderMethodNames}`;
+
+export interface WorkspaceQueryHookOptions {
+  key: WorkspaceQueryHookKey;
+  type?: WorkspaceQueryHookType;
+  scope?: Scope;
+}
+
+export function WorkspaceQueryHook(key: WorkspaceQueryHookKey): ClassDecorator;
+export function WorkspaceQueryHook(
+  options: WorkspaceQueryHookOptions,
+): ClassDecorator;
+export function WorkspaceQueryHook(
+  keyOrOptions?: WorkspaceQueryHookKey | WorkspaceQueryHookOptions,
+): ClassDecorator {
+  const options: WorkspaceQueryHookOptions =
+    keyOrOptions && typeof keyOrOptions === 'object'
+      ? keyOrOptions
+      : { key: keyOrOptions! };
+
+  // Default to PreHook
+  if (!options.type) {
+    options.type = WorkspaceQueryHookType.PreHook;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  return (target: Function) => {
+    SetMetadata(SCOPE_OPTIONS_METADATA, options)(target);
+    SetMetadata(HOOK_METADATA, options)(target);
+  };
+}

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-pre-query-hook.interface.ts → packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-query-hook.interface.ts

@@ -1,6 +1,6 @@
 import { ResolverArgs } from 'src/engine/api/graphql/workspace-resolver-builder/interfaces/workspace-resolvers-builder.interface';
 
-export interface WorkspacePreQueryHook {
+export interface WorkspaceQueryHookInstance {
   execute(
     userId: string | undefined,
     workspaceId: string,

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-query-hook.type.ts

@@ -0,0 +1,4 @@
+export enum WorkspaceQueryHookType {
+  PreHook = 'PreHook',
+  PostHook = 'PostHook',
+}

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/storage/workspace-query-hook.storage.ts

@@ -0,0 +1,59 @@
+// hook-registry.service.ts
+import { Injectable } from '@nestjs/common';
+import { Module } from '@nestjs/core/injector/module';
+
+import { WorkspaceQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-query-hook.interface';
+
+import { WorkspaceQueryHookKey } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/decorators/workspace-query-hook.decorator';
+
+interface WorkspaceQueryHookData<T> {
+  instance: T;
+  host: Module;
+  isRequestScoped: boolean;
+}
+
+@Injectable()
+export class WorkspaceQueryHookStorage {
+  private preHookInstances = new Map<
+    WorkspaceQueryHookKey,
+    WorkspaceQueryHookData<WorkspaceQueryHookInstance>[]
+  >();
+  private postHookInstances = new Map<
+    WorkspaceQueryHookKey,
+    WorkspaceQueryHookData<WorkspaceQueryHookInstance>[]
+  >();
+
+  registerWorkspaceQueryPreHookInstance(
+    key: WorkspaceQueryHookKey,
+    data: WorkspaceQueryHookData<WorkspaceQueryHookInstance>,
+  ) {
+    if (!this.preHookInstances.has(key)) {
+      this.preHookInstances.set(key, []);
+    }
+
+    this.preHookInstances.get(key)?.push(data);
+  }
+
+  getWorkspaceQueryPreHookInstances(
+    key: WorkspaceQueryHookKey,
+  ): WorkspaceQueryHookData<WorkspaceQueryHookInstance>[] | undefined {
+    return this.preHookInstances.get(key);
+  }
+
+  registerWorkspaceQueryPostHookInstance(
+    key: WorkspaceQueryHookKey,
+    data: WorkspaceQueryHookData<WorkspaceQueryHookInstance>,
+  ) {
+    if (!this.postHookInstances.has(key)) {
+      this.postHookInstances.set(key, []);
+    }
+
+    this.postHookInstances.get(key)?.push(data);
+  }
+
+  getWorkspaceQueryPostHookInstances(
+    key: WorkspaceQueryHookKey,
+  ): WorkspaceQueryHookData<WorkspaceQueryHookInstance>[] | undefined {
+    return this.postHookInstances.get(key);
+  }
+}

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/workspace-query-hook-metadata.accessor.ts

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { Injectable, Type } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+
+import { HOOK_METADATA } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/workspace-query-hook.constants';
+import { WorkspaceQueryHookOptions } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/decorators/workspace-query-hook.decorator';
+
+@Injectable()
+export class WorkspaceQueryHookMetadataAccessor {
+  constructor(private readonly reflector: Reflector) {}
+
+  isWorkspaceQueryHook(target: Type<any> | Function): boolean {
+    if (!target) {
+      return false;
+    }
+
+    return !!this.reflector.get(HOOK_METADATA, target);
+  }
+
+  getWorkspaceQueryHookMetadata(
+    target: Type<any> | Function,
+  ): WorkspaceQueryHookOptions | undefined {
+    return this.reflector.get(HOOK_METADATA, target);
+  }
+}

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/workspace-query-hook.constants.ts

@@ -0,0 +1 @@
+export const HOOK_METADATA = Symbol('hook:metadata');

packages/twenty-server/src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/workspace-query-hook.explorer.ts

@@ -0,0 +1,142 @@
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+import { DiscoveryService, ModuleRef, createContextId } from '@nestjs/core';
+import { Module } from '@nestjs/core/injector/module';
+import { Injector } from '@nestjs/core/injector/injector';
+
+import { WorkspaceQueryHookType } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-query-hook.type';
+import { WorkspaceQueryHookInstance } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/interfaces/workspace-query-hook.interface';
+
+import { WorkspaceQueryHookMetadataAccessor } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/workspace-query-hook-metadata.accessor';
+import { WorkspaceQueryHookStorage } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/storage/workspace-query-hook.storage';
+import { WorkspaceQueryHookKey } from 'src/engine/api/graphql/workspace-query-runner/workspace-pre-query-hook/decorators/workspace-query-hook.decorator';
+
+@Injectable()
+export class WorkspaceQueryHookExplorer implements OnModuleInit {
+  private readonly logger = new Logger('WorkspaceQueryHookModule');
+  private readonly injector = new Injector();
+
+  constructor(
+    private readonly moduleRef: ModuleRef,
+    private readonly discoveryService: DiscoveryService,
+    private readonly metadataAccessor: WorkspaceQueryHookMetadataAccessor,
+    private readonly workspaceQueryHookStorage: WorkspaceQueryHookStorage,
+  ) {}
+
+  onModuleInit() {
+    this.explore();
+  }
+
+  async explore() {
+    console.log('EXPLORE !');
+    const hooks = this.discoveryService
+      .getProviders()
+      .filter((wrapper) =>
+        this.metadataAccessor.isWorkspaceQueryHook(
+          !wrapper.metatype || wrapper.inject
+            ? wrapper.instance?.constructor
+            : wrapper.metatype,
+        ),
+      );
+
+    console.log('HOOKS: ', hooks.length);
+
+    for (const hook of hooks) {
+      const { instance, metatype } = hook;
+
+      const { key, type } =
+        this.metadataAccessor.getWorkspaceQueryHookMetadata(
+          instance.constructor || metatype,
+        ) ?? {};
+
+      if (!key || !type) {
+        this.logger.error(
+          `PreHook ${hook.name} is missing key or type metadata`,
+        );
+        continue;
+      }
+
+      if (!hook.host) {
+        this.logger.error(`PreHook ${hook.name} is missing host metadata`);
+
+        continue;
+      }
+
+      this.registerWorkspaceQueryHook(
+        key,
+        type,
+        instance,
+        hook.host,
+        !hook.isDependencyTreeStatic(),
+      );
+    }
+  }
+
+  async handleHook(
+    payload: Parameters<WorkspaceQueryHookInstance['execute']>,
+    instance: object,
+    host: Module,
+    isRequestScoped: boolean,
+  ) {
+    const methodName = 'execute';
+
+    if (isRequestScoped) {
+      const contextId = createContextId();
+
+      if (this.moduleRef.registerRequestByContextId) {
+        this.moduleRef.registerRequestByContextId(
+          {
+            req: {
+              workspaceId: payload?.[1],
+            },
+          },
+          contextId,
+        );
+      }
+
+      const contextInstance = await this.injector.loadPerContext(
+        instance,
+        host,
+        host.providers,
+        contextId,
+      );
+
+      await contextInstance[methodName].call(contextInstance, ...payload);
+    } else {
+      await instance[methodName].call(instance, ...payload);
+    }
+  }
+
+  private registerWorkspaceQueryHook(
+    key: WorkspaceQueryHookKey,
+    type: WorkspaceQueryHookType,
+    instance: object,
+    host: Module,
+    isRequestScoped: boolean,
+  ) {
+    switch (type) {
+      case WorkspaceQueryHookType.PreHook:
+        this.workspaceQueryHookStorage.registerWorkspaceQueryPreHookInstance(
+          key,
+          {
+            instance: instance as WorkspaceQueryHookInstance,
+            host,
+            isRequestScoped,
+          },
+        );
+        break;
+      case WorkspaceQueryHookType.PostHook:
+        this.workspaceQueryHookStorage.registerWorkspaceQueryPostHookInstance(
+          key,
+          {
+            instance: instance as WorkspaceQueryHookInstance,
+            host,
+            isRequestScoped,
+          },
+        );
+        break;
+      default:
+        this.logger.error(`Unknown WorkspaceQueryHookType: ${type}`);
+        break;
+    }
+  }
+}