Skip to content

hollowverse-archive/class-sanitizer

Folders and files

NameName
Last commit message
Last commit date

Latest commit

a2e3907 · Feb 1, 2018

History

42 Commits
Feb 1, 2018
Feb 1, 2018
Jan 24, 2018
Jan 23, 2018
Jan 24, 2018
Jan 23, 2018
Feb 1, 2018
Jan 24, 2018
Feb 1, 2018
Jan 24, 2018
Jan 24, 2018
Jan 24, 2018
Jan 24, 2018

Repository files navigation

hollowverse/class-sanitizer Build Status

Allows to use decorator and non-decorator based sanitization in your Typescript classes. Internally uses validator.js to make sanitization.

Installation

npm install @hollowverse/class-sanitizer --save

Usage

Create your class and put some sanity decorators on its properties you want to sanitize:

import { sanitize, Trim, Rtrim, Blacklist } from 'class-sanitizer';

export class Post {
  @Trim() title: string;

  @Rtrim(['.'])
  @Blacklist(/(1-9)/)
  text: string;
}

let post1 = new Post();
post1.title = ' Hello world ';
post1.text = '1. this is a great (2) post about hello 3 world.';

sanitize(post);
console.log(post);
// now post will look like this:
// Post {
// title: "Hello world",
// text: ". this is a great  post about hello  world"
// }

Custom sanitization classes

If you have custom sanity logic you want to use as annotations you can do it this way:

  1. First create a file, lets say LetterReplacer.ts, and create there a new class:

    import { SanitizerInterface, SanitizerConstraint } from 'class-sanitizer';
    
    @SanitizerConstraint()
    export class LetterReplacer implements SanitizerInterface {
      sanitize(text: string): string {
        return text.replace(/o/g, 'w');
      }
    }

    Your class must implement SanitizerInterface interface and its sanitize method, which defines sanitization logic.

  2. Then you can use your new sanitization constraint in your class:

    import { Sanitize } from 'class-sanitizer';
    import { LetterReplacer } from './LetterReplacer';
    
    export class Post {
      @Sanitize(LetterReplacer) title: string;
    }

    Here we set our newly created LetterReplacer sanitization constraint for Post.title.

  3. Now you can use sanitizer as usual:

    import { sanitize } from 'class-sanitizer';
    
    sanitize(post);

Using service container

Sanitizer supports service container in the case if want to inject dependencies into your custom sanity constraint classes. Here is example how to integrate it with typedi:

import { Container } from 'typedi';
import { Sanitizer } from 'class-sanitizer';

// do this somewhere in the global application level:
let sanitizer = Container.get(Sanitizer);
sanitizer.container = Container;

// now everywhere you can inject `Sanitizer` class which will go from the container
// also you can inject classes using constructor injection into your custom sanitizers.

Manual sanitization

There are several methodw in the Sanitizer that allows to perform non-decorator based sanitization:

import Sanitizer from 'class-sanitizer';

Sanitizer.blacklist(str, chars);
Sanitizer.escape(str);
Sanitizer.ltrim(str, chars);
Sanitizer.normalizeEmail(str, isLowercase);
Sanitizer.rtrim(str, chars);
Sanitizer.stripLow(str, keepNewLines);
Sanitizer.toBoolean(input, isStrict);
Sanitizer.toDate(input);
Sanitizer.toFloat(input);
Sanitizer.toInt(input, radix);
Sanitizer.toString(input);
Sanitizer.trim(str, chars);
Sanitizer.whitelist(str, chars);
Sanitizer.toUpperCase(str);
Sanitizer.toLowerCase(str);

Sanitization decorators

Decorator Description
@Blacklist(chars: RegExp) Remove characters that appear in the blacklist.
@Escape() Replace <, >, &, ', " and / with HTML entities.
@Ltrim() Trim characters from the left-side of the input.
@NormalizeEmail() Canonicalize an email address.
@Rtrim() Trim characters from the right-side of the input.
@StripLow() Remove characters with a numerical value < 32 and 127, mostly control characters.
@ToBoolean(isStrict?: boolean) Convert the input to a boolean. Everything except for '0', 'false' and '' returns true. In strict mode only '1' and 'true' return true.
@ToDate() Convert the input to a date, or null if the input is not a date.
@ToFloat() Convert the input to a float.
@ToInt() Convert the input to an integer, or NaN if the input is not an integer.
@ToString() Convert the input to a string.
@Trim(chars?: string[]) Trim characters (whitespace by default) from both sides of the input. You can specify chars that should be trimmed.
@Whitelist(chars: RegExp) Remove characters that do not appear in the whitelist.* The characters are used in a RegExp and so you will need to escape some chars, e.g. whitelist(input, '\[\]').
@ToUpperCase() (self-explanatory)
@ToLowerCase() (self-explanatory)

Examples

Take a look at the tests for more examples of usages.

About

Class-based sanitation in Typescript using decorators

Resources

Stars

Watchers

Forks

Packages

No packages published

Languages

  • TypeScript 98.1%
  • JavaScript 1.9%