@nestjs/common#createParamDecorator TypeScript Examples

User = createParamDecorator((data: undefined | keyof RequestUser, ctx: ExecutionContext) => {
  const request = ctx.switchToHttp().getRequest<ExtRequest>()

  const user = request.user

  if (data && typeof data === 'string' && typeof user === 'object') {
    return user[data]
  } else {
    return user
  }
})

QueueRole = createParamDecorator(
  async (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const queue = await QueueModel.findOne(request.params.queueId);
    const courseId = queue?.courseId;
    const user = await UserModel.findOne(request.user.userId, {
      relations: ['courses'],
    });

    const userCourse = user.courses.find((course) => {
      return Number(course.courseId) === Number(courseId);
    });

    if (!userCourse) {
      throw new NotFoundException(
        "cannot read propery 'role ' of undefined on user: " + user.id + user,
      );
    }
    return userCourse.role;
  },
)

CourseRole = createParamDecorator(
  async (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const courseId = request.params.courseId;
    const user = await UserModel.findOne(request.user.userId, {
      relations: ['courses'],
    });

    const userCourse = user.courses.find((course) => {
      return Number(course.courseId) === Number(courseId);
    });
    return userCourse.role;
  },
)

User = createParamDecorator(// tslint:disable-line variable-name
	(path: string[] = [], context: ExecutionContext): unknown => {
		const request = context.switchToHttp().getRequest() as IncomingMessage;

		const jwtResult = jwt.decode(request.headers.authorization.replace('Bearer ', '')) as any;

		return propOr(null, 'user')(jwtResult);
	}
)

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;
  },
)

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;
  }
)

RecaptchaResult = createParamDecorator((data, context: ExecutionContext) => {
    switch (context.getType<'http' | 'graphql'>()) {
        case 'http':
            return context.switchToHttp().getRequest().recaptchaValidationResult;
        case 'graphql':
            const graphqlModule = loadModule('@nestjs/graphql', true);
            return graphqlModule.GqlExecutionContext.create(context).getContext().req?.connection?._httpMessage?.req?.recaptchaValidationResult;
        default:
            return null;
    }
})

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)
})

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

    if (!user) {
      return null
    }

    return user
  },
)

Paginate = createParamDecorator((_data: unknown, ctx: ExecutionContext): PaginateQuery => {
    const request: Request = ctx.switchToHttp().getRequest()
    const { query } = request

    // Determine if Express or Fastify to rebuild the original url and reduce down to protocol, host and base url
    let originalUrl
    if (request.originalUrl) {
        originalUrl = request.protocol + '://' + request.get('host') + request.originalUrl
    } else {
        originalUrl = request.protocol + '://' + request.hostname + request.url
    }
    const urlParts = new URL(originalUrl)
    const path = urlParts.protocol + '//' + urlParts.host + urlParts.pathname

    const sortBy: [string, string][] = []
    const searchBy: string[] = []

    if (query.sortBy) {
        const params = !Array.isArray(query.sortBy) ? [query.sortBy] : query.sortBy
        for (const param of params) {
            if (isString(param)) {
                const items = param.split(':')
                if (items.length === 2) {
                    sortBy.push(items as [string, string])
                }
            }
        }
    }

    if (query.searchBy) {
        const params = !Array.isArray(query.searchBy) ? [query.searchBy] : query.searchBy
        for (const param of params) {
            if (isString(param)) {
                searchBy.push(param)
            }
        }
    }

    const filter = mapKeys(
        pickBy(
            query,
            (param, name) =>
                name.includes('filter.') &&
                (isString(param) || (Array.isArray(param) && (param as any[]).every((p) => isString(p))))
        ) as Dictionary<string | string[]>,
        (_param, name) => name.replace('filter.', '')
    )

    return {
        page: query.page ? parseInt(query.page.toString(), 10) : undefined,
        limit: query.limit ? parseInt(query.limit.toString(), 10) : undefined,
        sortBy: sortBy.length ? sortBy : undefined,
        search: query.search ? query.search.toString() : undefined,
        searchBy: searchBy.length ? searchBy : undefined,
        filter: Object.keys(filter).length ? filter : undefined,
        path,
    }
})

Context = createParamDecorator(
  (_data: unknown, context: ExecutionContext): BaseContext => {
    const request = context.switchToHttp().getRequest<Request>();
    return request.context;
  },
)

ReqContext = createParamDecorator(
  (data: unknown, ctx: ExecutionContext): RequestContext => {
    const request = ctx.switchToHttp().getRequest();

    return createRequestContext(request);
  },
)

User = createParamDecorator((data, req) => req.user)

AuthUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;
  },
)

CaslSubject = createParamDecorator(async (data: unknown, context: ExecutionContext) => {
  return new SubjectProxy(await ContextProxy.create(context).getRequest());
})

HttpUser: () => any = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
  const request: HttpRequestWithUser = ctx.switchToHttp().getRequest();
  return request.user;
})

User = createParamDecorator<string[]>(
  async (relations: string[], ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return await UserModel.findOne(request.user.userId, { relations });
  },
)

UserId = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return Number(request.user.userId);
  },
)

RequestUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user;
  },
)

GetUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext): UserInfo => {
    const req = ctx.switchToHttp().getRequest();
    console.log('user', req.user);
    return req.user;
  },
)

UserData = createParamDecorator<undefined, ExecutionContext, User>(
  (data, ctx: ExecutionContext) => userFactory(ctx)
)

Car = createParamDecorator(
  (data: string, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    const car = request.car;

    return data ? car && car[data] : car;
  },
)

AuthBearer = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const { headers } = ctx.switchToHttp().getRequest();

    return headers.authorization.split(' ')[1];
  },
)

RequestUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user as UserDocument;
  },
)

RequestUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user as User;
  },
)

RequestUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user as UserEntity;
  },
)

RequestUser = createParamDecorator(
  (data: unknown, ctx: ExecutionContext) => {
    const request = ctx.switchToHttp().getRequest();
    return request.user as UserEntity;
  },
)

SignIn = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
  const args = ctx.getArgs()[1]

  return {username: args.username, password: args.password}
})

CurrentUser = createParamDecorator((data: unknown, ctx: ExecutionContext) => {
  return ctx
})