From 453882b6fd05a744982478e7be03407c7339ee23 Mon Sep 17 00:00:00 2001
From: yassinedorbozgithub <yassine.dorboz.2022@gmail.com>
Date: Mon, 7 Oct 2024 15:37:08 +0100
Subject: [PATCH] feat(api): eventemitter types definitions

---
 api/src/eventemitter.d.ts | 247 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 247 insertions(+)
 create mode 100644 api/src/eventemitter.d.ts

diff --git a/api/src/eventemitter.d.ts b/api/src/eventemitter.d.ts
new file mode 100644
index 00000000..71588244
--- /dev/null
+++ b/api/src/eventemitter.d.ts
@@ -0,0 +1,247 @@
+import { OnEventOptions } from '@nestjs/event-emitter/dist/interfaces';
+import { Socket } from 'socket.io';
+
+import { BotStats } from '@/analytics/schemas/bot-stats.schema';
+import { Attachment } from '@/attachment/schemas/attachment.schema';
+import { Block, BlockFull } from '@/chat/schemas/block.schema';
+import { Category } from '@/chat/schemas/category.schema';
+import { ContextVar } from '@/chat/schemas/context-var.schema';
+import { Conversation } from '@/chat/schemas/conversation.schema';
+import { Label } from '@/chat/schemas/label.schema';
+import { Message } from '@/chat/schemas/message.schema';
+import { Subscriber } from '@/chat/schemas/subscriber.schema';
+import { ContentType } from '@/cms/schemas/content-type.schema';
+import { Content } from '@/cms/schemas/content.schema';
+import { Menu } from '@/cms/schemas/menu.schema';
+import { Language } from '@/i18n/schemas/language.schema';
+import { Translation } from '@/i18n/schemas/translation.schema';
+import { NlpEntity } from '@/nlp/schemas/nlp-entity.schema';
+import { NlpSampleEntity } from '@/nlp/schemas/nlp-sample-entity.schema';
+import { NlpSample } from '@/nlp/schemas/nlp-sample.schema';
+import { NlpValue } from '@/nlp/schemas/nlp-value.schema';
+import { Setting } from '@/setting/schemas/setting.schema';
+import { Invitation } from '@/user/schemas/invitation.schema';
+import { Model } from '@/user/schemas/model.schema';
+import { Permission } from '@/user/schemas/permission.schema';
+import { Role } from '@/user/schemas/role.schema';
+import { User } from '@/user/schemas/user.schema';
+import { EHook } from '@/utils/generics/base-repository';
+
+import { SubscriberUpdateDto } from './chat/dto/subscriber.dto';
+
+import '@nestjs/event-emitter';
+
+/**
+ * @description Module declaration that extends the NestJS EventEmitter with custom event types and methods.
+ */
+declare module '@nestjs/event-emitter' {
+  interface TDefinition<S, O = object> {
+    schema: S;
+    operations: O;
+  }
+  interface IHookOperationMap {
+    analytics: TDefinition<
+      object,
+      {
+        block: BlockFull;
+        passation: Subscriber;
+        'fallback-local': BlockFull;
+        'fallback-global': any;
+      }
+    >;
+    chatbot: TDefinition<
+      object,
+      {
+        sent: unknown;
+        received: unknown;
+        message: unknown;
+        delivery: unknown;
+        read: unknown;
+        typing: unknown;
+        follow: unknown;
+        echo: unknown;
+      }
+    >;
+    nlp: TDefinition<object, { settings: unknown }>;
+    websocket: TDefinition<
+      object,
+      {
+        connection: Socket;
+      }
+    >;
+  }
+  interface IHookEntityOperationMap extends IHookOperationMap {
+    stats: TDefinition<BotStats, { entry: string }>;
+    attachment: TDefinition<Attachment>;
+    block: TDefinition<Block>;
+    category: TDefinition<Category>;
+    contextVar: TDefinition<ContextVar>;
+    conversation: TDefinition<Conversation, { end: unknown; close: unknown }>;
+    label: TDefinition<
+      Label,
+      { create: THydratedDocument<Label>; delete: Label[] }
+    >;
+    message: TDefinition<Message>;
+    subscriber: TDefinition<Subscriber, { assign: SubscriberUpdateDto }>;
+    contentType: TDefinition<ContentType>;
+    content: TDefinition<Content>;
+    menu: TDefinition<Menu>;
+    language: TDefinition<Language, { delete: unknown }>;
+    translation: TDefinition<Translation>;
+    nlpEntity: TDefinition<
+      NlpEntity,
+      {
+        create: NlpEntity;
+        update: NlpEntity;
+        delete: NlpEntity;
+      }
+    >;
+    nlpSampleEntity: TDefinition<NlpSampleEntity>;
+    nlpSample: TDefinition<NlpSample>;
+    nlpValue: TDefinition<
+      NlpValue,
+      { create: NlpValue; update: NlpValue; delete: unknown }
+    >;
+    setting: TDefinition<Setting>;
+    invitation: TDefinition<Invitation>;
+    model: TDefinition<Model>;
+    permission: TDefinition<Permission>;
+    role: TDefinition<Role>;
+    user: TDefinition<User, { lastvisit: Subscriber }>;
+  }
+
+  /**
+   * @description A constrained string type that allows specific string values while preserving type safety.
+   */
+  type ConstrainedString = string & Record<never, never>;
+
+  type TCompatibleHook<
+    P extends 'pre' | 'post',
+    T = `${EHook}`,
+  > = T extends `${P}${infer I}` ? `${P}${I}` : never;
+
+  type TPreHook = TCompatibleHook<'pre'>;
+  type TPostHook = TCompatibleHook<'post'>;
+
+  type hookTypes = '*' | TPreHook | TPostHook;
+
+  /* hooks values  */
+  type TPostValidate<T> = THydratedDocument<T>;
+  type TPostCreate<T> = THydratedDocument<T>;
+  type TPostUpdate<T> = THydratedDocument<T>;
+  type TPostDelete = {
+    acknowledged: boolean;
+    deletedCount: number;
+  };
+  type TPost<T> = TPostValidate<T> &
+    TPostCreate<T> &
+    TPostUpdate<T> &
+    TPostDelete;
+
+  type EventNamespaces = keyof IHookEntityOperationMap;
+
+  type EventValueOf<G> = G extends EventNamespaces
+    ? IHookEntityOperationMap[G]
+    : G extends `hook:${infer N}:${hookTypes}`
+      ? IHookEntityOperationMap[N]['schema']
+      : G extends `hook:${infer N}:${infer O}`
+        ? IHookEntityOperationMap[N]['operations'][O]
+        : any;
+
+  type IsHookEvent<G extends EventNamespaces> = G extends EventNamespaces
+    ? true
+    : G extends `hook:${infer N}:${string}`
+      ? N extends keyof IHookEntityOperationMap
+        ? true
+        : false
+      : false;
+
+  type customEvent<G extends EventNamespaces> = G extends EventNamespaces
+    ? G extends `hook:${string}`
+      ? G
+      : `hook:${G}:${hookTypes | keyof IHookEntityOperationMap[G]['operations']}`
+    : never;
+
+  export interface ListenerFn<G extends EventNamespaces | ConstrainedString> {
+    (value: EventValueOf<G>, ...values: any[]): void;
+  }
+
+  export class EventEmitter2 {
+    emit<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      value: EventValueOf<G>,
+      ...values: any[]
+    ): boolean;
+
+    emitAsync<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      value: EventValueOf<G>,
+      ...values: any[]
+    ): Promise<any[]>;
+
+    addListener<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      listener: ListenerFn<G>,
+    ): this | Listener;
+
+    on<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      listener: ListenerFn<G>,
+      options?: boolean | OnOptions,
+    ): this | Listener;
+
+    once<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      listener: ListenerFn<G>,
+      options?: true | OnOptions,
+    ): this | Listener;
+
+    prependOnceListener<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      listener: ListenerFn<G>,
+      options?: boolean | OnOptions,
+    ): this | Listener;
+
+    many<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      timesToListen: number,
+      listener: ListenerFn<G>,
+      options?: boolean | OnOptions,
+    ): this | Listener;
+
+    prependMany<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      timesToListen: number,
+      listener: ListenerFn<G>,
+      options?: boolean | OnOptions,
+    ): this | Listener;
+
+    removeListener<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      listener: ListenerFn<G>,
+    ): this;
+
+    off<G extends EventNamespaces | ConstrainedString>(
+      customEvent: customEvent<G>,
+      listener: ListenerFn<G>,
+    ): this;
+  }
+
+  declare type OnEventMethodDecorator<
+    G extends EventNamespaces | ConstrainedString,
+  > = <T, K extends keyof T>(
+    target: IsHookEvent<G> extends true
+      ? [T[K]] extends [(params: EventValueOf<G>, ...rest: any[]) => any]
+        ? T
+        : never
+      : T,
+    propertyKey: K,
+  ) => void;
+
+  export declare function OnEvent<
+    G extends EventNamespaces | ConstrainedString,
+  >(
+    event: customEvent<G>,
+    options?: OnEventOptions | undefined,
+  ): OnEventMethodDecorator<G>;
+}