@nestjs/graphql#GqlExecutionContext TypeScript Examples

/**
   * getRequest return ExecutionContext as GqlExecutionContext request
   *
   * @param context
   */
  getRequest(context: ExecutionContext) {
    const ctx = GqlExecutionContext.create(context)

    return ctx.getContext().req
  }

UserRoles = createParamDecorator(
  (data: string, context: ExecutionContext) => {
    const ctx = GqlExecutionContext.create(context);
    const request = ctx.getContext<{ req: { user: any } }>().req;
    if (!request.user) {
      return null;
    }
    return data ? request.user[data] : request.user.roles;
  }
)

/**
 * Access the user data from the request object i.e `req.user`.
 */
function userFactory(ctx: ExecutionContext): User {
  const contextType = ctx.getType();
  if (contextType === "http") {
    // do something that is only important in the context of regular HTTP requests (REST)
    const { user } = ctx.switchToHttp().getRequest();
    return user;
  } else if (contextType === "rpc") {
    // do something that is only important in the context of Microservice requests
    throw new Error("Rpc context is not implemented yet");
  } else if (contextType === "ws") {
    // do something that is only important in the context of Websockets requests
    throw new Error("Websockets context is not implemented yet");
  } else if (ctx.getType<GqlContextType>() === "graphql") {
    // do something that is only important in the context of GraphQL requests
    const gqlExecutionContext = GqlExecutionContext.create(ctx);
    return gqlExecutionContext.getContext().req.user;
  }
  throw new Error("Invalid context");
}

canActivate(context: ExecutionContext): boolean {
    const ctx = GqlExecutionContext.create(context);

    const roles = this.reflector.get<string[]>('roles', ctx.getHandler());
    if (!roles) {
      return true;
    }

    const userRoles = ctx.getContext().req.user ? ctx.getContext().req.user.roles : []

    for (const role of roles) {
      if (!userRoles.includes(role)) {
        return false;
      }
    }

    return true;
  }

/**
   * Returns whether the request is authorized to activate the handler
   */
  async canActivate(context: ExecutionContext): Promise<boolean> {
    // Check context with AuthGuard
    if (!(await super.canActivate(context))) {
      return false;
    }

    const ctx = GqlExecutionContext.create(context);
    const req = this.getRequest(context);
    const currentUser = req.user;
    const handler = context.getHandler();

    const requestArgs = ctx.getArgByIndex(1);

    return (
      this.canActivateRoles(handler, currentUser) &&
      (await this.authorizeContext(handler, requestArgs, currentUser))
    );
  }

intercept(context: ExecutionContext, next: CallHandler) {
    const handler = context.getHandler();
    const graphqlContext = GqlExecutionContext.create(context);
    const { req } = graphqlContext.getContext();
    const args = graphqlContext.getArgs();

    const params = this.getInjectContextValueParameters(handler);

    if (!params) {
      return next.handle();
    }

    const { parameterPath, parameterType } = params;

    const parameterValue = this.getInjectableContextValue(
      req.user,
      parameterType
    );

    set(args, parameterPath, parameterValue);

    return next.handle();
  }

mockGqlAuthGuardCanActivate = (user: object) => (
  executionContext: ExecutionContext
): boolean => {
  const gqlExecutionContext = GqlExecutionContext.create(executionContext);
  const gqlContext = gqlExecutionContext.getContext();
  // Set user for injectContextValue to work properly
  set(gqlContext, ['req', 'user'], user);
  return true;
}

getRequest(context: ExecutionContext) {
    if (context.getType<any>() === 'graphql') {
      const ctx = GqlExecutionContext.create(context);

      if (!ctx.getContext().cache) {
        ctx.getContext().cache = new ContextCache()
      }
      return ctx.getContext().req;
    }

    return context.switchToHttp().getRequest()
  }

Tracing = createParamDecorator(
  (key: keyof TracingData, context: ExecutionContext) => {
    const contextType = context.getType<GqlContextType>();
    let tracingData: TracingData;
    if (contextType === 'graphql') {
      const ctx = GqlExecutionContext.create(context);
      tracingData = ctx.getContext<TracingObject>().tracing;
    }
    if (contextType === 'http') {
      const ctx = context.switchToHttp();
      tracingData = ctx.getRequest<TracingObject>().tracing;
    }
    if (contextType === 'rpc') {
      const ctx = context.switchToRpc();
      tracingData = ctx.getContext<TracingObject>().tracing;
    }
    return key ? tracingData && tracingData[key] : tracingData;
  },
)

User = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const user = GqlExecutionContext.create(ctx).getContext().req.user

    if (!user) {
      return null
    }

    return user
  },
)

IpAddress = createParamDecorator((data: string, ctx: ExecutionContext) => {
  let req

  if (ctx.getType<string>() === 'graphql') {
    req = GqlExecutionContext.create(ctx).getContext().req
  } else {
    req = ctx.switchToHttp().getRequest()
  }

  if (req.clientIp) {
    return req.clientIp
  }

  return getClientIp(req)
})

export function extractRequest(context: ExecutionContext): any {
  if (context.getType<GqlContextType>() === 'graphql') {
    const gqlContext = GqlExecutionContext.create(context)
    return gqlContext.getContext().req
  }
  return context.switchToHttp().getRequest()
}

getRequest(context: ExecutionContext) {
    const ctx = GqlExecutionContext.create(context);
    return ctx.getContext().req;
  }

canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const ctx = GqlExecutionContext.create(context);
    const { req } = ctx.getContext();

    return Boolean(req.user && Object.values(Roles).includes(req.user.role));
  }

canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const ctx = GqlExecutionContext.create(context);
    const { req } = ctx.getContext();

    return Boolean(req.user && req.user.role === Roles.ADMIN);
  }

getRequest(context: ExecutionContext) {
    return GqlExecutionContext.create(context).getContext().req
  }

async intercept(context: ExecutionContext, next: CallHandler): Promise<Observable<any>> {
        const ctx = GqlExecutionContext.create(context);
        const {environmentNameOrId} = ctx.getArgs();
        const environment = await this.systemProvider.getEnvironment(environmentNameOrId);
        ctx.getContext().environment = environment;

        return next.handle();
    }

async canActivate(context: ExecutionContext): Promise<boolean> {
        const ctx = GqlExecutionContext.create(context);
        const {fieldName} = ctx.getInfo();
        const {environmentNameOrId} = ctx.getArgs();
        const environment = await this.systemProvider.getEnvironment(environmentNameOrId);

        return environment.supports(fieldName);
    }

canActivate(context: ExecutionContext): boolean {
    const ctx = GqlExecutionContext.create(context);
    return true;
  }

// This method is required for the interface - do not delete it.
  getRequest(context: ExecutionContext) {
    const ctx = GqlExecutionContext.create(context);
    return ctx.getContext().req;
  }

export function getUser(executionContext: ExecutionContext): User {
  const gqlExecutionContext = GqlExecutionContext.create(executionContext);
  return gqlExecutionContext.getContext().req.user;
}

// This method is required for the interface - do not delete it.
  getRequest(context: ExecutionContext): Request {
    const ctx = GqlExecutionContext.create(context);
    return ctx.getContext<{ req: Request }>().req;
  }

async getUser(context: ExecutionContext): Promise<User> {
    const ctx = GqlExecutionContext.create(context);
    const request = ctx.getContext<{ req: { user: User } }>().req;
    return request.user;
  }

getRequest(context: ExecutionContext) {
    const ctx = GqlExecutionContext.create(context);
    return ctx.getContext().req;
  }

intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    const contextType = context.getType<GqlContextType>();
    const except = this.reflector.get<boolean>(
      EXCEPT_TRACING,
      context.getHandler(),
    );
    if (contextType === 'ws') {
      return next.handle();
    }
    if (except) {
      if (contextType === 'rpc') {
        const ctx = context.switchToRpc();
        const data = ctx.getData<TracingContext>();
        if (isTracingContext(data)) {
          context.getArgs()[0] = data.payload;
        }
      }
      return next.handle();
    }
    let parentSpanContext: SpanContext;
    const spanTags = new Map<string, unknown>();
    const spanLogs: Array<Record<string, unknown>> = [];
    const constructorRef = context.getClass().name;
    const handler = context.getHandler().name;
    const operation = [contextType, constructorRef, handler].join(':');
    const tracingData: TracingData = { operation };
    spanTags.set('operation', operation);
    spanTags.set(Tags.COMPONENT, contextType);
    if (contextType === 'graphql') {
      const ctx = GqlExecutionContext.create(context);
      ctx.getContext<TracingObject>().tracing = tracingData;
      const { path } = ctx.getInfo<GraphQLResolveInfo>();
      spanTags.set('graphql.name', `${path?.key}`);
      spanTags.set('graphql.type', `${path?.typename}`.toLowerCase());
    }
    if (contextType === 'http') {
      const ctx = context.switchToHttp();
      ctx.getRequest<TracingObject>().tracing = tracingData;
      const { statusCode } = ctx.getResponse<Response>();
      const { headers, method, path, ip, ips } = ctx.getRequest<Request>();
      spanTags.set(Tags.HTTP_URL, path);
      spanTags.set(Tags.HTTP_METHOD, `${method}`.toUpperCase());
      spanTags.set(Tags.PEER_HOST_IPV4, [ip, ...ips].join(', '));
      spanTags.set(Tags.HTTP_STATUS_CODE, statusCode);
      parentSpanContext = this.tracerProvider.extractHeaders(headers);
    }
    if (contextType === 'rpc') {
      const ctx = context.switchToRpc();
      const data = ctx.getData<TracingContext>();
      if (isTracingContext(data)) {
        const { payload, tracing } = data;
        context.getArgs()[0] = payload;
        tracingData.parent = tracing;
        parentSpanContext = this.tracerProvider.extractTracing(tracing);
      }
      ctx.getContext<TracingObject>().tracing = tracingData;
      if (typeof ctx.getContext().getPattern === 'function') {
        const pattern = ctx.getContext().getPattern();
        spanTags.set('rpc.pattern', pattern);
      }
      if (typeof ctx.getContext().getChannel === 'function') {
        const channel = ctx.getContext().getChannel();
        spanTags.set('rpc.channel', channel);
      }
      if (typeof ctx.getContext().getSubject === 'function') {
        const subject = ctx.getContext().getSubject();
        spanTags.set('rpc.subject', subject);
      }
      if (typeof ctx.getContext().getTopic === 'function') {
        const topic = ctx.getContext().getTopic();
        spanTags.set('rpc.topic', topic);
      }
      spanLogs.push({ payload: JSON.stringify(ctx.getData(), null, 2) });
    }
    return this.asyncContext.run(() => {
      const span = this.tracer.startSpan(operation, {
        childOf: parentSpanContext,
        tags: { kind: 'server' },
      });
      spanTags.forEach((value: string, key: string) => {
        span.setTag(key, value);
      });
      spanLogs.forEach((log) => {
        span.log(log);
      });
      tracingData.carrier = this.tracerProvider.getCarrier(span);
      this.asyncContext.set(TRACING_CARRIER_INFO, tracingData);
      return next.handle().pipe(
        tap(() => {
          span.finish();
        }),
        catchError((error: Error) => {
          span.setTag(Tags.ERROR, true);
          if (error instanceof HttpException) {
            const tag =
              contextType === 'http'
                ? Tags.HTTP_STATUS_CODE
                : 'error.status_code';
            span.setTag(tag, error.getStatus());
          }
          span.log({
            event: Tags.ERROR,
            'error.object': error,
            message: error.message,
            stack: error.stack,
          });
          span.finish();
          return throwError(error);
        }),
      );
    }) as Observable<unknown>;
  }