feat(rules): Added Mimetype rule

Author: ricardogobbosouza

README.md

@@ -121,6 +121,7 @@ The library can be loaded either as a standalone script, or through an [AMD](htt
 - [Luhn](docs/luhn.md)
 - [MacAddress](docs/mac-address.md)
 - [Max](docs/max.md)
+- [Mimetype](docs/mimetype.md)
 - [Min](docs/min.md)
 - [Multiple](docs/multiple.md)
 - [Negative](docs/negative.md)

awesome-validator.min.js

@@ -0,0 +1,18 @@
+# Mimetype
+
+Validates if the file mimetype matches the expected one.
+
+Valid values:
+
+```js
+validator.mimetype('application/javascript').validate('js');
+validator.mimetype('application/json').validate('json');
+validator.mimetype('text/plain').validate('txt');
+```
+
+Invalid values:
+
+```js
+validator.mimetype('foo').validate('bar');
+validator.mimetype('txt').validate('foo/txt');
+```

docs/mimetype.md

@@ -58,6 +58,8 @@
     }
   },
   "dependencies": {
+    "@types/mime-types": "^2.1.0",
+    "mime-types": "^2.1.17",
     "moment": "^2.19.3"
   },
   "devDependencies": {

package-lock.json

@@ -42,6 +42,7 @@ export * from './lowercase';
 export * from './luhn';
 export * from './mac-address';
 export * from './max';
+export * from './mimetype';
 export * from './min';
 export * from './multiple';
 export * from './negative';

package.json

@@ -0,0 +1,20 @@
+import { lookup } from 'mime-types';
+
+import { AbstractRule } from './abstract-rule';
+
+export class Mimetype extends AbstractRule {
+
+    /**
+     * Mimetype.
+     */
+    public constructor(public readonly mimetype: string) {
+        super();
+    }
+
+    /**
+     * Validate.
+     */
+    public validate(input: any): boolean {
+        return lookup(input) === this.mimetype;
+    }
+}

src/rules/index.ts

@@ -52,6 +52,7 @@ export class Validator extends AllOf {
     public static luhn = (): Validator => new Validator(new rules.Luhn());
     public static macAddress = (): Validator => new Validator(new rules.MacAddress());
     public static max = (interval?: any, inclusive: boolean = true): Validator => new Validator(new rules.Max(interval, inclusive));
+    public static mimetype = (mimetype: string): Validator => new Validator(new rules.Mimetype(mimetype));
     public static min = (interval?: any, inclusive: boolean = true): Validator => new Validator(new rules.Min(interval, inclusive));
     public static multiple = (multipleOf: number): Validator => new Validator(new rules.Multiple(multipleOf));
     public static negative = (): Validator => new Validator(new rules.Negative());
@@ -160,6 +161,7 @@ export class Validator extends AllOf {
     public luhn = (): this => this.addRule(new rules.Luhn());
     public macAddress = (): this => this.addRule(new rules.MacAddress());
     public max = (interval?: any, inclusive: boolean = true): this => this.addRule(new rules.Max(interval, inclusive));
+    public mimetype = (mimetype: string): this => this.addRule(new rules.Mimetype(mimetype));
     public min = (interval?: any, inclusive: boolean = true): this => this.addRule(new rules.Min(interval, inclusive));
     public multiple = (multipleOf: number): this => this.addRule(new rules.Multiple(multipleOf));
     public negative = (): this => this.addRule(new rules.Negative());

src/rules/mimetype.ts

@@ -0,0 +1,23 @@
+import { assert } from 'chai';
+
+import { AbstractRule } from '../../src/rules/abstract-rule';
+import { Mimetype } from '../../src/rules/mimetype';
+
+describe('Mimetype', () => {
+
+    it('is rule', () => {
+        assert.instanceOf(new Mimetype('foo'), AbstractRule);
+    });
+
+    it('values is valid', () => {
+        assert.isTrue(new Mimetype('application/javascript').validate('js'));
+        assert.isTrue(new Mimetype('application/json').validate('json'));
+        assert.isTrue(new Mimetype('text/plain').validate('txt'));
+    });
+
+    it('values is not valid', () => {
+        assert.isFalse(new Mimetype('foo').validate('bar'));
+        assert.isFalse(new Mimetype('txt').validate('foo/txt'));
+    });
+
+});

src/validator.ts

@@ -80,6 +80,7 @@ describe('Validator', () => {
         assert.instanceOf(V.max(undefined), V);
         assert.instanceOf(V.max(100), V);
         assert.instanceOf(V.max(100, false), V);
+        assert.instanceOf(V.mimetype('foo'), V);
         assert.instanceOf(V.min(), V);
         assert.instanceOf(V.min(null), V);
         assert.instanceOf(V.min(undefined), V);
@@ -240,6 +241,7 @@ describe('Validator', () => {
         assert.instanceOf(v.max(), V);
         assert.instanceOf(v.max(100), V);
         assert.instanceOf(v.max(100, false), V);
+        assert.instanceOf(v.mimetype('foo'), V);
         assert.instanceOf(v.min(), V);
         assert.instanceOf(v.min(100), V);
         assert.instanceOf(v.min(100, false), V);