20065394908

Committed 09 Dec 2025 01:36PM UTC coverage: 71.858%. First build

Build # 20065394908

Build Type

Pull #2168

github

Committed by

web-flow

Commit Message

Merge b9dc7a0f8 into 6fd609a47

Pull Request Pull Request #2168: feat: base node

Run Details

22892 of 25545 branches covered (89.61%)

1916 of 2478 new or added lines in 35 files covered. (77.32%)

57741 of 80354 relevant lines covered (71.86%)

4259.47 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.34

/apps/nestjs-backend/src/event-emitter/interceptor/event.Interceptor.ts

/* eslint-disable @typescript-eslint/no-explicit-any */
import type { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
import { Injectable } from '@nestjs/common';
import { Reflector } from '@nestjs/core';
import type { Request } from 'express';
import type { Observable } from 'rxjs';
import { tap } from 'rxjs';
import { match, P } from 'ts-pattern';
import { EMIT_EVENT_NAME } from '../decorators/emit-controller-event.decorator';
import { EventEmitterService } from '../event-emitter.service';
import type { IEventContext } from '../events';
import {
  Events,
  BaseEventFactory,
  SpaceEventFactory,
  DashboardEventFactory,
  AppEventFactory,
  WorkflowEventFactory,
} from '../events';
import { BaseNodeEventFactory } from '../events/base/base-node.event';

@Injectable()
export class EventMiddleware implements NestInterceptor {
  constructor(
    private readonly reflector: Reflector,
    private readonly eventEmitterService: EventEmitterService
  ) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const req = context.switchToHttp().getRequest<Request>();
    const emitEventName = this.reflector.get<Events>(EMIT_EVENT_NAME, context.getHandler());

    return next.handle().pipe(
      tap((data) => {
        const interceptContext = this.interceptContext(req, data);

        const event = this.createEvent(emitEventName, interceptContext);
        event
          ? this.eventEmitterService.emitAsync(event.name, event)
          : this.eventEmitterService.emitAsync(emitEventName, interceptContext);
      })
    );
  }

  private interceptContext(req: Request, resolveData: any) {
    return {
      reqUser: req?.user as any,
      reqHeaders: req?.headers,
      reqParams: req?.params,
      reqQuery: req?.query,
      reqBody: req?.body,
      resolveData,
    };
  }

  private createEvent(
    eventName: Events,
    interceptContext: ReturnType<typeof this.interceptContext>
  ) {
    const { reqUser, reqHeaders, reqParams, resolveData } = interceptContext;

    const eventContext: IEventContext = {
      user: reqUser,
      headers: reqHeaders,
    };

    return match(eventName)
      .with(Events.BASE_DELETE, () =>
        BaseEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)
      )
      .with(P.union(Events.BASE_CREATE, Events.BASE_UPDATE, Events.BASE_PERMISSION_UPDATE), () =>
        BaseEventFactory.create(eventName, { base: resolveData, ...reqParams }, eventContext)
      )
      .with(Events.SPACE_DELETE, () =>
        SpaceEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)
      )
      .with(P.union(Events.SPACE_CREATE, Events.SPACE_UPDATE), () =>
        SpaceEventFactory.create(eventName, { space: resolveData, ...reqParams }, eventContext)
      )
      .with(Events.WORKFLOW_DELETE, () =>
        WorkflowEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)
      )
      .with(P.union(Events.WORKFLOW_CREATE, Events.WORKFLOW_UPDATE), () =>
        WorkflowEventFactory.create(
          eventName,
          { baseId: reqParams.baseId, workflow: resolveData, ...reqParams },
          eventContext
        )
      )
      .with(Events.APP_DELETE, () =>
        AppEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)
      )
      .with(P.union(Events.APP_CREATE, Events.APP_UPDATE), () =>
        AppEventFactory.create(
          eventName,
          { baseId: reqParams.baseId, app: resolveData, ...reqParams },
          eventContext
        )
      )
      .with(Events.DASHBOARD_DELETE, () =>
        DashboardEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)
      )
      .with(P.union(Events.DASHBOARD_CREATE, Events.DASHBOARD_UPDATE), () =>
        DashboardEventFactory.create(
          eventName,
          { baseId: reqParams.baseId, dashboard: resolveData, ...reqParams },
          eventContext
        )
      )

      .with(
        P.union(Events.BASE_NODE_CREATE, Events.BASE_NODE_UPDATE, Events.BASE_NODE_DELETE),
        () => {
          const { baseId } = reqParams;
          return BaseNodeEventFactory.create(
            eventName,
            { baseId, node: resolveData },
            eventContext
          );
        }
      )

      .otherwise(() => null);
  }
}

1	/* eslint-disable @typescript-eslint/no-explicit-any */	8✔
2	import type { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
3	import { Injectable } from '@nestjs/common';
4	import { Reflector } from '@nestjs/core';
5	import type { Request } from 'express';
6	import type { Observable } from 'rxjs';
7	import { tap } from 'rxjs';
8	import { match, P } from 'ts-pattern';
9	import { EMIT_EVENT_NAME } from '../decorators/emit-controller-event.decorator';
10	import { EventEmitterService } from '../event-emitter.service';
11	import type { IEventContext } from '../events';
12	import {
13	Events,
14	BaseEventFactory,
15	SpaceEventFactory,
16	DashboardEventFactory,
17	AppEventFactory,
18	WorkflowEventFactory,
19	} from '../events';
20	import { BaseNodeEventFactory } from '../events/base/base-node.event';
21
22	@Injectable()
23	export class EventMiddleware implements NestInterceptor {	8✔
24	constructor(	1,110✔
25	private readonly reflector: Reflector,	1,110✔
26	private readonly eventEmitterService: EventEmitterService	1,110✔
27	) {}	1,110✔
28
29	intercept(context: ExecutionContext, next: CallHandler): Observable<any> {	1,110✔
30	const req = context.switchToHttp().getRequest<Request>();	1,729✔
31	const emitEventName = this.reflector.get<Events>(EMIT_EVENT_NAME, context.getHandler());	1,729✔
32
33	return next.handle().pipe(	1,729✔
34	tap((data) => {	1,729✔
35	const interceptContext = this.interceptContext(req, data);	1,690✔
36
37	const event = this.createEvent(emitEventName, interceptContext);	1,690✔
38	event	1,690✔
39	? this.eventEmitterService.emitAsync(event.name, event)	723✔
40	: this.eventEmitterService.emitAsync(emitEventName, interceptContext);	967✔
41	})	1,690✔
42	);
43	}	1,729✔
44
45	private interceptContext(req: Request, resolveData: any) {	1,110✔
46	return {	1,690✔
47	reqUser: req?.user as any,	1,690✔
48	reqHeaders: req?.headers,	1,690✔
49	reqParams: req?.params,	1,690✔
50	reqQuery: req?.query,	1,690✔
51	reqBody: req?.body,	1,690✔
52	resolveData,	1,690✔
53	};	1,690✔
54	}	1,690✔
55
56	private createEvent(	1,110✔
57	eventName: Events,	1,690✔
58	interceptContext: ReturnType<typeof this.interceptContext>	1,690✔
59	) {	1,690✔
60	const { reqUser, reqHeaders, reqParams, resolveData } = interceptContext;	1,690✔
61
62	const eventContext: IEventContext = {	1,690✔
63	user: reqUser,	1,690✔
64	headers: reqHeaders,	1,690✔
65	};	1,690✔
66
67	return match(eventName)	1,690✔
68	.with(Events.BASE_DELETE, () =>	1,690✔
69	BaseEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)	163✔
70	)
71	.with(P.union(Events.BASE_CREATE, Events.BASE_UPDATE, Events.BASE_PERMISSION_UPDATE), () =>	1,690✔
72	BaseEventFactory.create(eventName, { base: resolveData, ...reqParams }, eventContext)	197✔
73	)
74	.with(Events.SPACE_DELETE, () =>	1,690✔
75	SpaceEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)	84✔
76	)
77	.with(P.union(Events.SPACE_CREATE, Events.SPACE_UPDATE), () =>	1,690✔
78	SpaceEventFactory.create(eventName, { space: resolveData, ...reqParams }, eventContext)	85✔
79	)
80	.with(Events.WORKFLOW_DELETE, () =>	1,690✔
NEW 81	WorkflowEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)	×
82	)
83	.with(P.union(Events.WORKFLOW_CREATE, Events.WORKFLOW_UPDATE), () =>	1,690✔
NEW 84	WorkflowEventFactory.create(	×
NEW 85	eventName,	×
NEW 86	{ baseId: reqParams.baseId, workflow: resolveData, ...reqParams },	×
NEW 87	eventContext	×
88	)
89	)
90	.with(Events.APP_DELETE, () =>	1,690✔
NEW 91	AppEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)	×
92	)
93	.with(P.union(Events.APP_CREATE, Events.APP_UPDATE), () =>	1,690✔
NEW 94	AppEventFactory.create(	×
NEW 95	eventName,	×
NEW 96	{ baseId: reqParams.baseId, app: resolveData, ...reqParams },	×
NEW 97	eventContext	×
98	)
99	)
100	.with(Events.DASHBOARD_DELETE, () =>	1,690✔
101	DashboardEventFactory.create(eventName, { ...resolveData, ...reqParams }, eventContext)	16✔
102	)
103	.with(P.union(Events.DASHBOARD_CREATE, Events.DASHBOARD_UPDATE), () =>	1,690✔
104	DashboardEventFactory.create(	24✔
105	eventName,	24✔
106	{ baseId: reqParams.baseId, dashboard: resolveData, ...reqParams },	24✔
107	eventContext	24✔
108	)
109	)
110
111	.with(	1,690✔
112	P.union(Events.BASE_NODE_CREATE, Events.BASE_NODE_UPDATE, Events.BASE_NODE_DELETE),	1,690✔
113	() => {	1,690✔
114	const { baseId } = reqParams;	215✔
115	return BaseNodeEventFactory.create(	215✔
116	eventName,	215✔
117	{ baseId, node: resolveData },	215✔
118	eventContext	215✔
119	);
120	}	215✔
121	)
122
123	.otherwise(() => null);	1,690✔
124	}	1,690✔
125	}	1,110✔

teableio / teable / 20065394908

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous