Merge pull request #164 from switcherapi/patch_162

Patch 162

Author: petruki

package.json

@@ -57,9 +57,9 @@
     "jsonwebtoken": "^8.5.1",
     "moment": "^2.29.1",
     "mongodb": "^3.3.3",
-    "mongoose": "^5.11.9",
-    "switcher-client": "^3.0.0",
-    "validator": "^12.0.0"
+    "mongoose": "^5.12.7",
+    "switcher-client": "^3.0.1",
+    "validator": "^13.6.0"
   },
   "devDependencies": {
     "@babel/cli": "^7.7.4",

src/controller/component.js

@@ -13,6 +13,10 @@ export async function getComponents(where) {
     return Component.find(where);
 }
 
+export async function getTotalComponentsByDomainId(domain) {
+    return Component.find({ domain }).countDocuments();
+}
+
 export async function createComponent(args, admin) {
     let component = new Component({
         ...args,

src/controller/config.js

@@ -23,6 +23,10 @@ export async function getConfigs(where) {
     return Config.find(where);
 }
 
+export async function getTotalConfigsByDomainId(domain) {
+    return Config.find({ domain }).countDocuments();
+}
+
 export async function createConfig(args, admin) {
     // validates account plan permissions
     const group = await getGroupConfigById(args.group);

src/controller/domain.js

@@ -20,6 +20,10 @@ export async function getDomain(where) {
     return response(domain, 'Domain not found');
 }
 
+export async function getTotalDomainsByOwner(owner) {
+    await Domain.find({ owner }).countDocuments();
+}
+
 export async function createDomain(args, admin) {
     let domain = new Domain({
         ...args,

src/controller/environment.js

@@ -43,6 +43,10 @@ export async function getEnvironment(where) {
     return response(environment, 'Environment not found');
 }
 
+export async function getTotalEnvByDomainId(domain) {
+    return Environment.find({ domain }).countDocuments();
+}
+
 export async function createEnvironment(args, admin) {
     let environment = new Environment({
         ...args, 

src/controller/group-config.js

@@ -21,6 +21,10 @@ export async function getGroupConfigs(where) {
     return GroupConfig.find(where);
 }
 
+export async function getGroupsByDomainId(domain) {
+    await GroupConfig.find({ domain }).countDocuments();
+}
+
 export async function createGroup(args, admin) {
     let groupconfig = new GroupConfig({
         ...args,

src/controller/team.js

@@ -58,6 +58,10 @@ export async function getTeamInvite(where, validate = true) {
     return teamInvite;
 }
 
+export async function getTotalTeamsByDomainId(domain) {
+    return Team.find({ domain }).countDocuments();
+}
+
 export async function createTeam(args, admin, defaultActions) {
     let team = new Team({
         ...args

src/external/switcher-api-facade.js

@@ -1,11 +1,12 @@
-import Switcher from 'switcher-client';
-import Domain from '../models/domain';
-import GroupConfig from '../models/group-config';
-import { Config } from '../models/config';
-import Component from '../models/component';
-import { Environment, EnvType } from '../models/environment';
-import { Team } from '../models/team';
+import { Switcher, checkNumeric, checkValue } from 'switcher-client';
+import { EnvType } from '../models/environment';
 import { FeatureUnavailableError } from '../exceptions';
+import { getDomainById, getTotalDomainsByOwner } from '../controller/domain';
+import { getGroupsByDomainId } from '../controller/group-config';
+import { getTotalConfigsByDomainId } from '../controller/config';
+import { getTotalComponentsByDomainId } from '../controller/component';
+import { getTotalEnvByDomainId } from '../controller/environment';
+import { getTotalTeamsByDomainId } from '../controller/team';
 
 const apiKey = process.env.SWITCHER_API_KEY;
 const environment = process.env.SWITCHER_API_ENVIRONMENT;
@@ -26,79 +27,73 @@ export async function checkDomain(req) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
-    const total = await Domain.find({ owner: req.admin._id }).countDocuments();
+    const total = await getTotalDomainsByOwner(req.admin._id);
     switcherFlagResult(await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `domain#${req.admin._id}`, 
-        Switcher.StrategiesType.NUMERIC, total]
-    ), 'Domain limit has been reached.');
+        checkValue(`domain#${req.admin._id}`),
+        checkNumeric(total)]), 'Domain limit has been reached.');
 }
 
 export async function checkGroup(domain) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
-    const total = await GroupConfig.find({ domain: domain._id }).countDocuments();
+    const total = await getGroupsByDomainId(domain._id);
     switcherFlagResult(await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `group#${domain.owner}`, 
-        Switcher.StrategiesType.NUMERIC, total]
-    ), 'Group limit has been reached.');
+        checkValue(`group#${domain.owner}`),
+        checkNumeric(total)]), 'Group limit has been reached.');
 }
 
 export async function checkSwitcher(group) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
-    const total = await Config.find({ domain: group.domain }).countDocuments();
-    const { owner } = await Domain.findById(group.domain).lean();
+    const total = await getTotalConfigsByDomainId(group.domain);
+    const { owner } = await getDomainById(group.domain);
     switcherFlagResult(await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `switcher#${owner}`, 
-        Switcher.StrategiesType.NUMERIC, total]
-    ), 'Switcher limit has been reached.');
+        checkValue(`switcher#${owner}`),
+        checkNumeric(total)]), 'Switcher limit has been reached.');
 }
 
 export async function checkComponent(domain) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
-    const total = await Component.find({ domain }).countDocuments();
-    const { owner } = await Domain.findById(domain).lean();
+    const total = await getTotalComponentsByDomainId(domain);
+    const { owner } = await getDomainById(domain);
     switcherFlagResult(await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `component#${owner}`, 
-        Switcher.StrategiesType.NUMERIC, total]
-    ), 'Component limit has been reached.');
+        checkValue(`component#${owner}`),
+        checkNumeric(total)]), 'Component limit has been reached.');
 }
 
 export async function checkEnvironment(domain) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
-    const total = await Environment.find({ domain }).countDocuments();
-    const { owner } = await Domain.findById(domain).lean();
+    const total = await getTotalEnvByDomainId(domain);
+    const { owner } = await getDomainById(domain);
     switcherFlagResult(await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `environment#${owner}`, 
-        Switcher.StrategiesType.NUMERIC, total]
-    ), 'Environment limit has been reached.');
+        checkValue(`environment#${owner}`),
+        checkNumeric(total)]), 'Environment limit has been reached.');
 }
 
 export async function checkTeam(domain) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
-    const total = await Team.find({ domain }).countDocuments();
-    const { owner } = await Domain.findById(domain).lean();
+    const total = await getTotalTeamsByDomainId(domain);
+    const { owner } = await getDomainById(domain);
     switcherFlagResult(await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `team#${owner}`, 
-        Switcher.StrategiesType.NUMERIC, total]
-    ), 'Team limit has been reached.');
+        checkValue(`team#${owner}`),
+        checkNumeric(total)]), 'Team limit has been reached.');
 }
 
 export async function checkMetrics(config) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return true;
 
-    const { owner } = await Domain.findById(config.domain).lean();
+    const { owner } = await getDomainById(config.domain);
     if (!await switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `metrics#${owner}`])) {
+        checkValue(`metrics#${owner}`)])) {
 
         if (!config.disable_metrics) {
             config.disable_metrics = new Map();
@@ -115,32 +110,31 @@ export async function checkHistory(domain) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return true;
 
-    const { owner } = await Domain.findById(domain).lean();
+    const { owner } = await getDomainById(domain);
     return switcher.isItOn('ELEMENT_CREATION', [
-        Switcher.StrategiesType.VALUE, `history#${owner}`]);
+        checkValue(`history#${owner}`)]);
 }
 
 export async function checkAdmin(login) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
     switcherFlagResult(await switcher.isItOn('ACCOUNT_CREATION', [
-        Switcher.StrategiesType.VALUE, login]
-    ), 'Account not released to use the API.');
+        checkValue(login)]), 'Account not released to use the API.');
 }
 
 export function notifyAcCreation(adminid) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
     switcher.isItOn('ACCOUNT_IN_NOTIFY', [
-        Switcher.StrategiesType.VALUE, adminid]);
+        checkValue(adminid)]);
 }
 
 export function notifyAcDeletion(adminid) {
     if (process.env.SWITCHER_API_ENABLE != 'true')
         return;
 
     switcher.isItOn('ACCOUNT_OUT_NOTIFY', [
-        Switcher.StrategiesType.VALUE, adminid]);
+        checkValue(adminid)]);
 }

tests/unit-test/switcher-api-facade.test.js

@@ -23,7 +23,7 @@ import {
     groupConfigDocument,
     config1Document
 } from '../fixtures/db_api';
-import Switcher from 'switcher-client';
+import { Switcher } from 'switcher-client';
 
 afterAll(async () => {
     await new Promise(resolve => setTimeout(resolve, 1000));