add blockList option

Author: xr0master

src/errors/blockedEmailError/blockedEmailError.spec.ts

@@ -0,0 +1,15 @@
+import { it, expect } from '@jest/globals';
+
+import { EmailJSResponseStatus } from '../../models/EmailJSResponseStatus';
+import { blockedEmailError } from './blockedEmailError';
+
+it('should return EmailJSResponseStatus', () => {
+  expect(blockedEmailError()).toBeInstanceOf(EmailJSResponseStatus);
+});
+
+it('should return status 403', () => {
+  expect(blockedEmailError()).toEqual({
+    status: 403,
+    text: 'Forbidden',
+  });
+});

src/errors/blockedEmailError/blockedEmailError.ts

@@ -0,0 +1,5 @@
+import { EmailJSResponseStatus } from '../../models/EmailJSResponseStatus';
+
+export const blockedEmailError = () => {
+  return new EmailJSResponseStatus(403, 'Forbidden');
+};

src/methods/init/init.spec.ts

@@ -6,7 +6,6 @@ import { store } from '../../store/store';
 beforeEach(() => {
   store.origin = 'https://api.emailjs.com';
   store.limitRate = 0;
-  store.blockList = [];
   store.publicKey = undefined;
 });
 
@@ -18,7 +17,6 @@ describe('sdk v3', () => {
       origin: 'https://api.emailjs.com',
       publicKey: 'C2JWGTestKeySomething',
       limitRate: 0,
-      blockList: [],
     });
   });
 });
@@ -30,21 +28,24 @@ describe('sdk v4', () => {
     expect(store).toEqual({
       origin: 'https://api.emailjs.com',
       limitRate: 0,
-      blockList: [],
     });
   });
 
   it('should call the init method with custom options', () => {
     init({
       publicKey: 'C2JWGTestKeySomething',
-      blockList: ['block@email.com'],
+      blockList: {
+        list: ['block@email.com'],
+      },
       limitRate: 10000,
     });
 
     expect(store).toEqual({
       origin: 'https://api.emailjs.com',
       publicKey: 'C2JWGTestKeySomething',
-      blockList: ['block@email.com'],
+      blockList: {
+        list: ['block@email.com'],
+      },
       limitRate: 10000,
     });
   });

src/methods/init/init.ts

@@ -18,7 +18,7 @@ export const init = (
 
   store.publicKey = opts.publicKey;
   store.blockHeadless = opts.blockHeadless;
+  store.blockList = opts.blockList;
   store.limitRate = opts.limitRate || store.limitRate;
-  store.blockList = opts.blockList || store.blockList;
   store.origin = opts.origin || origin;
 };

src/store/store.ts

@@ -4,5 +4,4 @@ export const store: Options = {
   origin: 'https://api.emailjs.com',
   blockHeadless: false,
   limitRate: 0,
-  blockList: [],
 };

src/types/BlockList.ts

@@ -0,0 +1,4 @@
+export interface BlockList {
+  list?: string[];
+  watchVariable?: string;
+}

src/types/Options.ts

@@ -1,7 +1,9 @@
+import type { BlockList } from './BlockList';
+
 export interface Options {
   origin?: string;
   publicKey?: string;
   blockHeadless?: boolean;
+  blockList?: BlockList;
   limitRate?: number;
-  blockList?: string[];
 }

src/utils/isBlockedValue/isBlockedValue.spec.ts

@@ -0,0 +1,91 @@
+import { it, describe, expect } from '@jest/globals';
+import { isBlockedValueInParams } from './isBlockedValue';
+import type { BlockList } from '../../types/BlockList';
+
+describe('should be disabled', () => {
+  it('empty block list options', () => {
+    const blockList: BlockList = {};
+
+    expect(isBlockedValueInParams(blockList, {})).toBeFalsy();
+  });
+
+  it('without list', () => {
+    const blockList: BlockList = {
+      watchVariable: 'email',
+    };
+
+    expect(isBlockedValueInParams(blockList, {})).toBeFalsy();
+  });
+
+  it('without watchVariable', () => {
+    const blockList: BlockList = {
+      list: ['test@emailjs.com'],
+    };
+
+    expect(isBlockedValueInParams(blockList, {})).toBeFalsy();
+  });
+
+  it('without data', () => {
+    const blockList: BlockList = {
+      watchVariable: 'email',
+      list: ['test@emailjs.com'],
+    };
+
+    expect(isBlockedValueInParams(blockList, {})).toBeFalsy();
+  });
+
+  it('wrong type', () => {
+    const blockList: BlockList = {
+      watchVariable: 'email',
+      list: ['test@emailjs.com'],
+    };
+
+    expect(
+      isBlockedValueInParams(blockList, {
+        email: ['item', 'item'],
+      }),
+    ).toBeFalsy();
+  });
+
+  it('not found in the list', () => {
+    const blockList: BlockList = {
+      watchVariable: 'email',
+      list: ['test@emailjs.com', 'bar@emailjs.com'],
+    };
+
+    expect(
+      isBlockedValueInParams(blockList, {
+        email: 'foo@emailjs.com',
+      }),
+    ).toBeFalsy();
+  });
+});
+
+describe('should be enabled', () => {
+  it('template params', () => {
+    const blockList: BlockList = {
+      watchVariable: 'email',
+      list: ['test@emailjs.com', 'foo@emailjs.com', 'bar@emailjs.com'],
+    };
+
+    expect(
+      isBlockedValueInParams(blockList, {
+        email: 'test@emailjs.com',
+        other: 'other data',
+      }),
+    ).toBeTruthy();
+  });
+
+  it('form data', () => {
+    const blockList: BlockList = {
+      watchVariable: 'email',
+      list: ['test@emailjs.com', 'foo@emailjs.com', 'bar@emailjs.com'],
+    };
+
+    const formData = new FormData();
+    formData.append('email', 'test@emailjs.com');
+    formData.append('other', 'other data');
+
+    expect(isBlockedValueInParams(blockList, formData)).toBeTruthy();
+  });
+});

src/utils/isBlockedValue/isBlockedValue.ts

@@ -0,0 +1,22 @@
+import type { BlockList } from '../../types/BlockList';
+
+const isBlockListDisabled = (options: BlockList): boolean => {
+  return !options.list?.length || !options.watchVariable;
+};
+
+const getValue = (data: Record<string, unknown> | FormData, name: string): unknown => {
+  return data instanceof FormData ? data.get(name) : data[name];
+};
+
+export const isBlockedValueInParams = (
+  options: BlockList,
+  params: Record<string, unknown> | FormData,
+): boolean => {
+  if (isBlockListDisabled(options)) return false;
+
+  const value = getValue(params, options.watchVariable!);
+
+  if (typeof value !== 'string') return false;
+
+  return options.list!.includes(value);
+};