@nestjs/common#SetMetadata TypeScript Examples

export function Processor(
  queueNameOrOptions?: string | ProcessorOptions,
): ClassDecorator {
  const options =
    queueNameOrOptions && typeof queueNameOrOptions === 'object'
      ? queueNameOrOptions
      : { name: queueNameOrOptions };

  // eslint-disable-next-line @typescript-eslint/ban-types
  return (target: Function) => {
    SetMetadata(SCOPE_OPTIONS_METADATA, options)(target);
    SetMetadata(BULL_MODULE_QUEUE, options)(target);
  };
}

Listen: ListenOverload = <T>(
  source: string | Source,
  optionsOrConnection?: ListenOptions<T> | string,
  connectionName?: string,
): MethodDecorator => {
  return (target: Record<string, any>, propertyKey: string | symbol, descriptor: PropertyDescriptor) => {
    const connection = connectionName ?? (typeof optionsOrConnection === 'string' ? optionsOrConnection : AMQP_DEFAULT_CONNECTION_TOKEN);
    const options = typeof optionsOrConnection === 'object' ? optionsOrConnection : {};

    const metadata = new ListenerMetadata<T>({
      source,
      options,
      connection,
      targetName: target.constructor.name,
      target: target.constructor,
      callback: descriptor.value,
      callbackName: typeof propertyKey === 'string' ? propertyKey : propertyKey.toString(),
    });

    SetMetadata<string, ListenerMetadata<T>>(QUEUE_LISTEN_METADATA_KEY, metadata)(target, propertyKey, descriptor);
  };
}

export function Subscribe(topicOrOptions): CustomDecorator {
  if (typeof topicOrOptions === 'string' || Array.isArray(topicOrOptions)) {
    return SetMetadata(MQTT_SUBSCRIBE_OPTIONS, {
      topic: topicOrOptions,
    });
  } else {
    return SetMetadata(MQTT_SUBSCRIBE_OPTIONS, topicOrOptions);
  }
}

OnGlobalQueueEvent = (
  eventNameOrOptions: BullQueueGlobalEvents | BullQueueEventOptions,
): MethodDecorator =>
  SetMetadata(
    BULL_MODULE_ON_GLOBAL_QUEUE_EVENT,
    typeof eventNameOrOptions === 'string'
      ? { eventName: eventNameOrOptions }
      : eventNameOrOptions,
  )

export function GraphQLHook<T extends HookName>(hookName: T) {
  return (
    target: Function | Record<string, any>,
    key: any,
    descriptor?: TypedPropertyDescriptor<HookMap[T]>,
  ) => {
    SetMetadata(HOOK_METADATA, hookName)(target, key, descriptor);
  };
}

Public = (skipAuth = true) =>
  applyDecorators(
    SetMetadata(META_UNPROTECTED, true),
    SetMetadata(META_SKIP_AUTH, skipAuth),
  )

export function UseAbility<Subject = AnyObject, Request = AuthorizableRequest>(
  action: string,
  subject: AnyClass<Subject>,
  subjectHook?: AnyClass<SubjectBeforeFilterHook<Subject, Request>> | SubjectBeforeFilterTuple<Subject, Request>,
): CustomDecorator {
  return SetMetadata(CASL_META_ABILITY, { action, subject, subjectHook });
}

HasRoles = (...args: RoleType[]) => SetMetadata(HAS_ROLES_KEY, args)

Roles = (...roles: string[]) => SetMetadata('roles', roles)

export function ResolveLoader(
  propertyNameOrFunc?: string | ReturnTypeFunc,
  typeFuncOrOptions?: ReturnTypeFunc | ResolveLoaderOptions,
  resolveFieldOptions?: ResolveLoaderOptions,
): MethodDecorator {
  return (
    target: Function | Record<string, any>,
    key: any,
    descriptor?: any,
  ) => {
    // eslint-disable-next-line prefer-const
    let [propertyName, typeFunc, options] = isFunction(propertyNameOrFunc)
      ? typeFuncOrOptions && typeFuncOrOptions.name
        ? [typeFuncOrOptions.name, propertyNameOrFunc, typeFuncOrOptions]
        : [undefined, propertyNameOrFunc, typeFuncOrOptions]
      : [propertyNameOrFunc, typeFuncOrOptions, resolveFieldOptions];
    SetMetadata(LOADER_NAME_METADATA, propertyName)(target, key, descriptor);
    SetMetadata(LOADER_PROPERTY_METADATA, true)(target, key, descriptor);

    SetMetadata(
      FIELD_RESOLVER_MIDDLEWARE_METADATA,
      (options as ResolveLoaderOptions)?.middleware,
    )(target, key, descriptor);

    options = isObject(options)
      ? {
          name: propertyName as string,
          ...options,
        }
      : propertyName
      ? { name: propertyName as string }
      : {};

    LazyMetadataStorage.store(
      target.constructor as Type<unknown>,
      function resolveLoader() {
        let typeOptions: TypeOptions, typeFn: (type?: any) => GqlTypeReference;
        try {
          const implicitTypeMetadata = reflectTypeFromMetadata({
            metadataKey: 'design:returntype',
            prototype: target,
            propertyKey: key,
            explicitTypeFn: typeFunc as ReturnTypeFunc,
            typeOptions: options as any,
          });
          typeOptions = implicitTypeMetadata.options;
          typeFn = implicitTypeMetadata.typeFn;
        } catch {}

        TypeMetadataStorage.addResolverPropertyMetadata({
          kind: 'external',
          methodName: key,
          schemaName: options.name || key,
          target: target.constructor,
          typeFn,
          typeOptions,
          description: (options as ResolveLoaderOptions).description,
          deprecationReason: (options as ResolveLoaderOptions)
            .deprecationReason,
          complexity: (options as ResolveLoaderOptions).complexity,
        });
      },
    );
  };
}

Roles = (...roles: ROLE[]): CustomDecorator<string> =>
  SetMetadata(ROLES_KEY, roles)

Roles = (...roles: rolesType) => SetMetadata('roles', roles)

Roles = (...roles: RoleType[]) => SetMetadata('roles', roles)

Roles = (...roles: DefaultRole[]): CustomDecorator<string> => {
  return SetMetadata('roles', roles)
}

HttpAuth = (...roles: UserRole[]): (...args: any) => void => {
  return applyDecorators(
    SetMetadata('roles', roles),
    UseGuards(HttpJwtAuthGuard, HttpRoleAuthGuard)
  );
}

AuditLog = (eventName: string) => SetMetadata('auditLog', eventName)

Roles = (...roles: string[]): CustomDecorator<string> =>
  SetMetadata('roles', roles)

Roles = (...roles: string[]) => SetMetadata('roles', roles)

SqsMessageHandler = (name: string, batch?: boolean) => SetMetadata(SQS_CONSUMER_METHOD, { name, batch })

DefineScope = (scope: string): CustomDecorator<string> =>
  SetMetadata<string, string>(META_SCOPE, scope)

Roles = (...roles: RolesEnum[]) => SetMetadata('roles', roles)

PublicAuthMiddleware = SetMetadata(IS_PUBLIC_KEY, true)

FetchResources = (): CustomDecorator<string> =>
  SetMetadata<string, boolean>(META_FETCH_RESOURCES, true)

Unprotected = (skipAuth = true) =>
  applyDecorators(
    SetMetadata(META_UNPROTECTED, true),
    SetMetadata(META_SKIP_AUTH, skipAuth),
  )

Auth = (...levels: AdminLevel[]) => {
  return applyDecorators(
    SetMetadata('levels', levels),
    UseGuards(FirebaseAuthGuard, LevelsGuard),
  );
}

export function SetRecaptchaOptions(options?: VerifyResponseDecoratorOptions): MethodDecorator & ClassDecorator {
    return SetMetadata(RECAPTCHA_VALIDATION_OPTIONS, options);
}

Roles = (...roles: UserRole[]): CustomDecorator<typeof UserRole> =>
  SetMetadata(UserRole, roles)

export function FormDataRequest(config?: FormDataInterceptorConfig) {
  
  return applyDecorators(
    SetMetadata(FORM_DATA_REQUEST_METADATA_KEY, config),
    UseInterceptors(FormDataInterceptor),
  );

}

export function ExceptTracing(): MethodDecorator {
  return applyDecorators(SetMetadata(EXCEPT_TRACING, true));
}