@innet/server 2.0.0-alpha.9 → 2.0.0-beta.2

package/plugins/schema/object/object.es6.js

@@ -1,11 +1,13 @@
 import innet, { useNewHandler } from 'innet';
-import { useChildren, useProps } from '@innet/jsx';
+import { useProps } from '@innet/jsx';
+import { callHandler } from '@innet/utils';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
 import '../../../utils/index.es6.js';
 import { useBlock } from '../../../hooks/useBlock/useBlock.es6.js';
 import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { objectSchemaContext } from '../../../hooks/useObjectSchemaContext/useObjectSchemaContext.es6.js';
 import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
 import { parentRuleContext, useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
 import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
@@ -16,25 +18,28 @@ import { objectRuleContext } from '../../../hooks/useObjectRule/useObjectRule.es
 
 const object = () => {
     useBlock('path');
-    const children = useChildren();
-    const props = useProps() || {};
+    const { children, ...props } = useProps();
     const { refRules } = useApi();
     const schema = useSchemaType('object', props);
     const handler = useNewHandler();
     if (schema) {
-        schemaContext.set(handler, schema);
+        schema.additionalProperties = {};
+        objectSchemaContext.set(handler, schema);
+        schemaContext.set(handler, schema.additionalProperties);
         parentRuleContext.reset(handler);
         const rules = [];
         const rulesMap = {};
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
             rules.push(defaultTo(props.default));
         }
+        let childRule = v => v;
+        const restRule = (value, data) => childRule(value, data);
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(objectOf(rulesMap));
+            rules.push(objectOf(rulesMap, restRule));
         }
         else {
             const parentRule = useParentRule();
-            rules.push(parentRule(objectOf(rulesMap)));
+            rules.push(parentRule(objectOf(rulesMap, restRule)));
         }
         const rule = pipe(...rules);
         if (props.ref) {
@@ -42,9 +47,16 @@ const object = () => {
         }
         useRule(rule);
         objectRuleContext.set(handler, rulesMap);
-        ruleContext.set(handler, null);
+        ruleContext.set(handler, rule => {
+            childRule = rule;
+        });
         parentRuleContext.reset(handler);
         innet(children, handler);
+        innet(() => {
+            if (!Object.keys(schema.additionalProperties).length) {
+                delete schema.additionalProperties;
+            }
+        }, callHandler);
     }
     else if (props.ref) {
         useRule(refRules[props.ref]);

package/plugins/schema/object/object.js

@@ -4,12 +4,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var innet = require('innet');
 var jsx = require('@innet/jsx');
+var utils = require('@innet/utils');
 require('../../../hooks/index.js');
 require('../../../hooks/useParentRule/index.js');
 require('../../../utils/index.js');
 var useBlock = require('../../../hooks/useBlock/useBlock.js');
 var useApi = require('../../../hooks/useApi/useApi.js');
 var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var useObjectSchemaContext = require('../../../hooks/useObjectSchemaContext/useObjectSchemaContext.js');
 var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
 var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
@@ -24,25 +26,28 @@ var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
 
 const object = () => {
     useBlock.useBlock('path');
-    const children = jsx.useChildren();
-    const props = jsx.useProps() || {};
+    const { children, ...props } = jsx.useProps();
     const { refRules } = useApi.useApi();
     const schema = useSchemaType.useSchemaType('object', props);
     const handler = innet.useNewHandler();
     if (schema) {
-        useSchemaContext.schemaContext.set(handler, schema);
+        schema.additionalProperties = {};
+        useObjectSchemaContext.objectSchemaContext.set(handler, schema);
+        useSchemaContext.schemaContext.set(handler, schema.additionalProperties);
         useParentRule.parentRuleContext.reset(handler);
         const rules = [];
         const rulesMap = {};
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
             rules.push(defaultTo.defaultTo(props.default));
         }
+        let childRule = v => v;
+        const restRule = (value, data) => childRule(value, data);
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(objectOf.objectOf(rulesMap));
+            rules.push(objectOf.objectOf(rulesMap, restRule));
         }
         else {
             const parentRule = useParentRule.useParentRule();
-            rules.push(parentRule(objectOf.objectOf(rulesMap)));
+            rules.push(parentRule(objectOf.objectOf(rulesMap, restRule)));
         }
         const rule = pipe.pipe(...rules);
         if (props.ref) {
@@ -50,9 +55,16 @@ const object = () => {
         }
         useRule.useRule(rule);
         useObjectRule.objectRuleContext.set(handler, rulesMap);
-        useRule.ruleContext.set(handler, null);
+        useRule.ruleContext.set(handler, rule => {
+            childRule = rule;
+        });
         useParentRule.parentRuleContext.reset(handler);
         innet__default["default"](children, handler);
+        innet__default["default"](() => {
+            if (!Object.keys(schema.additionalProperties).length) {
+                delete schema.additionalProperties;
+            }
+        }, utils.callHandler);
     }
     else if (props.ref) {
         useRule.useRule(refRules[props.ref]);

package/plugins/schema/string/string.d.ts

@@ -1,9 +1,9 @@
 import { type HandlerPlugin } from 'innet';
 import { type ValuesSchemaProps } from '../../../types';
 export interface StringProps extends ValuesSchemaProps<string> {
-    min?: number;
     max?: number;
-    pattern?: string | RegExp;
+    min?: number;
+    pattern?: RegExp | string;
     patternId?: string;
 }
 export declare const string: HandlerPlugin;

package/plugins/schema/string/string.es6.js

@@ -1,50 +1,63 @@
-import { __rest } from 'tslib';
 import { useProps } from '@innet/jsx';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
 import '../../../utils/index.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
 import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
 import { values } from '../../../utils/rules/values/values.es6.js';
 import { minLength } from '../../../utils/rules/minLength/minLength.es6.js';
 import { maxLength } from '../../../utils/rules/maxLength/maxLength.es6.js';
 import { pattern } from '../../../utils/rules/pattern/pattern.es6.js';
-import { useRule } from '../../../hooks/useRule/useRule.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+import { useRule } from '../../../hooks/useRule/useRule.es6.js';
 import { useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
 
 const string = () => {
-    const _a = useProps() || {}, { min, max, pattern: pattern$1, patternId } = _a, props = __rest(_a, ["min", "max", "pattern", "patternId"]);
+    const { max, min, pattern: pattern$1, patternId, ...props } = useProps() || {};
+    const { refRules } = useApi();
     const schema = useSchemaType('string', props);
-    const rules = [];
-    if (props.default !== undefined) {
-        rules.push(defaultTo(props.default));
-    }
-    rules.push(String);
-    if (props.values) {
-        rules.push(values(props.values));
-    }
-    if (min !== undefined) {
-        // @ts-expect-error: FIXME
-        schema.minimum = min;
-        rules.push(minLength(min));
-    }
-    if (max !== undefined) {
-        // @ts-expect-error: FIXME
-        schema.maximum = max;
-        rules.push(maxLength(max));
-    }
-    if (pattern$1 !== undefined) {
-        // @ts-expect-error: FIXME
-        schema.pattern = String(pattern$1);
-        rules.push(pattern(pattern$1, patternId));
-    }
-    if (props.default) {
-        useRule(pipe(...rules));
+    if (schema) {
+        const rules = [];
+        if (props.default !== undefined) {
+            rules.push(defaultTo(props.default));
+        }
+        rules.push(String);
+        if (props.values) {
+            rules.push(values(props.values));
+        }
+        if (min !== undefined) {
+            schema.minimum = min;
+            rules.push(minLength(min));
+        }
+        if (max !== undefined) {
+            schema.maximum = max;
+            rules.push(maxLength(max));
+        }
+        if (pattern$1 !== undefined) {
+            schema.pattern = String(pattern$1);
+            rules.push(pattern(pattern$1, patternId));
+        }
+        const rule = pipe(...rules);
+        if (props.ref) {
+            refRules[props.ref] = rule;
+        }
+        if (props.default !== undefined) {
+            useRule(rule);
+        }
+        else {
+            const parentRule = useParentRule();
+            useRule(parentRule(rule));
+        }
     }
-    else {
-        const parentRule = useParentRule();
-        useRule(parentRule(pipe(...rules)));
+    else if (props.ref) {
+        if (props.default !== undefined) {
+            useRule(refRules[props.ref]);
+        }
+        else {
+            const parentRule = useParentRule();
+            useRule(parentRule(refRules[props.ref]));
+        }
     }
 };
 

package/plugins/schema/string/string.js

@@ -2,53 +2,66 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var jsx = require('@innet/jsx');
 require('../../../hooks/index.js');
 require('../../../hooks/useParentRule/index.js');
 require('../../../utils/index.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
 var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
 var values = require('../../../utils/rules/values/values.js');
 var minLength = require('../../../utils/rules/minLength/minLength.js');
 var maxLength = require('../../../utils/rules/maxLength/maxLength.js');
 var pattern = require('../../../utils/rules/pattern/pattern.js');
-var useRule = require('../../../hooks/useRule/useRule.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
 var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
 
 const string = () => {
-    const _a = jsx.useProps() || {}, { min, max, pattern: pattern$1, patternId } = _a, props = tslib.__rest(_a, ["min", "max", "pattern", "patternId"]);
+    const { max, min, pattern: pattern$1, patternId, ...props } = jsx.useProps() || {};
+    const { refRules } = useApi.useApi();
     const schema = useSchemaType.useSchemaType('string', props);
-    const rules = [];
-    if (props.default !== undefined) {
-        rules.push(defaultTo.defaultTo(props.default));
-    }
-    rules.push(String);
-    if (props.values) {
-        rules.push(values.values(props.values));
-    }
-    if (min !== undefined) {
-        // @ts-expect-error: FIXME
-        schema.minimum = min;
-        rules.push(minLength.minLength(min));
-    }
-    if (max !== undefined) {
-        // @ts-expect-error: FIXME
-        schema.maximum = max;
-        rules.push(maxLength.maxLength(max));
-    }
-    if (pattern$1 !== undefined) {
-        // @ts-expect-error: FIXME
-        schema.pattern = String(pattern$1);
-        rules.push(pattern.pattern(pattern$1, patternId));
-    }
-    if (props.default) {
-        useRule.useRule(pipe.pipe(...rules));
+    if (schema) {
+        const rules = [];
+        if (props.default !== undefined) {
+            rules.push(defaultTo.defaultTo(props.default));
+        }
+        rules.push(String);
+        if (props.values) {
+            rules.push(values.values(props.values));
+        }
+        if (min !== undefined) {
+            schema.minimum = min;
+            rules.push(minLength.minLength(min));
+        }
+        if (max !== undefined) {
+            schema.maximum = max;
+            rules.push(maxLength.maxLength(max));
+        }
+        if (pattern$1 !== undefined) {
+            schema.pattern = String(pattern$1);
+            rules.push(pattern.pattern(pattern$1, patternId));
+        }
+        const rule = pipe.pipe(...rules);
+        if (props.ref) {
+            refRules[props.ref] = rule;
+        }
+        if (props.default !== undefined) {
+            useRule.useRule(rule);
+        }
+        else {
+            const parentRule = useParentRule.useParentRule();
+            useRule.useRule(parentRule(rule));
+        }
     }
-    else {
-        const parentRule = useParentRule.useParentRule();
-        useRule.useRule(parentRule(pipe.pipe(...rules)));
+    else if (props.ref) {
+        if (props.default !== undefined) {
+            useRule.useRule(refRules[props.ref]);
+        }
+        else {
+            const parentRule = useParentRule.useParentRule();
+            useRule.useRule(parentRule(refRules[props.ref]));
+        }
     }
 };
 

package/plugins/schema/tuple/tuple.d.ts

@@ -1,5 +1,6 @@
 import { type HandlerPlugin } from 'innet';
 import { type BaseSchemaProps } from '../../../types';
 export interface TupleProps extends BaseSchemaProps<any[]> {
+    children?: any;
 }
 export declare const tuple: HandlerPlugin;

package/plugins/schema/tuple/tuple.es6.js

@@ -1,5 +1,5 @@
 import innet, { useNewHandler } from 'innet';
-import { useProps, useChildren } from '@innet/jsx';
+import { useProps } from '@innet/jsx';
 import { callHandler } from '@innet/utils';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
@@ -17,9 +17,8 @@ import { required } from '../../../utils/rules/required/required.es6.js';
 const tuple = () => {
     useBlock('path');
     const handler = useNewHandler();
-    const props = useProps();
+    const { children, ...props } = useProps();
     const schema = useSchemaType('array', props);
-    const children = useChildren();
     if (schema) {
         const schemas = [];
         handler[schemaContext.key] = schemas;
@@ -27,10 +26,10 @@ const tuple = () => {
         schema.prefixItems = schemas;
         const rulesMap = [];
         const rules = [];
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+        if (props.default !== undefined) {
             rules.push(defaultTo(props.default));
         }
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+        if (props.default !== undefined) {
             rules.push(tupleOf(rulesMap));
         }
         else {

package/plugins/schema/tuple/tuple.js

@@ -25,9 +25,8 @@ var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
 const tuple = () => {
     useBlock.useBlock('path');
     const handler = innet.useNewHandler();
-    const props = jsx.useProps();
+    const { children, ...props } = jsx.useProps();
     const schema = useSchemaType.useSchemaType('array', props);
-    const children = jsx.useChildren();
     if (schema) {
         const schemas = [];
         handler[useSchemaContext.schemaContext.key] = schemas;
@@ -35,10 +34,10 @@ const tuple = () => {
         schema.prefixItems = schemas;
         const rulesMap = [];
         const rules = [];
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+        if (props.default !== undefined) {
             rules.push(defaultTo.defaultTo(props.default));
         }
-        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+        if (props.default !== undefined) {
             rules.push(tupleOf.tupleOf(rulesMap));
         }
         else {

package/plugins/schema/uuid/uuid.es6.js

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { useProps } from '@innet/jsx';
 import { v4 } from 'uuid';
 import '../../../hooks/index.es6.js';
@@ -12,8 +11,11 @@ import { optional } from '../../../utils/rules/optional/optional.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 
 const uuid = () => {
-    const _a = useProps() || {}, { default: defaultValue } = _a, props = __rest(_a, ["default"]);
-    const schema = useSchemaType('string', Object.assign(Object.assign({}, props), { default: defaultValue === 'new' ? undefined : defaultValue }));
+    const { default: defaultValue, ...props } = useProps();
+    const schema = useSchemaType('string', {
+        ...props,
+        default: defaultValue === 'new' ? undefined : defaultValue,
+    });
     // @ts-expect-error: FIXME
     schema.format = 'uuid';
     if (defaultValue === 'new') {

package/plugins/schema/uuid/uuid.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var jsx = require('@innet/jsx');
 var uuid$1 = require('uuid');
 require('../../../hooks/index.js');
@@ -16,8 +15,11 @@ var optional = require('../../../utils/rules/optional/optional.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
 
 const uuid = () => {
-    const _a = jsx.useProps() || {}, { default: defaultValue } = _a, props = tslib.__rest(_a, ["default"]);
-    const schema = useSchemaType.useSchemaType('string', Object.assign(Object.assign({}, props), { default: defaultValue === 'new' ? undefined : defaultValue }));
+    const { default: defaultValue, ...props } = jsx.useProps();
+    const schema = useSchemaType.useSchemaType('string', {
+        ...props,
+        default: defaultValue === 'new' ? undefined : defaultValue,
+    });
     // @ts-expect-error: FIXME
     schema.format = 'uuid';
     if (defaultValue === 'new') {

package/plugins/utils/blacklist/blacklist.d.ts

@@ -0,0 +1,5 @@
+export interface BlacklistProps {
+    children?: any;
+    ip?: string | string[];
+}
+export declare function blacklist(): void;

package/plugins/utils/blacklist/blacklist.es6.js

@@ -0,0 +1,17 @@
+import { useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import { useServerPlugin } from '../../../hooks/useServerPlugin/useServerPlugin.es6.js';
+import { useAction } from '../../../hooks/useAction/useAction.es6.js';
+
+function blacklist() {
+    const { children, ip = process.env.INNET_BLACKLIST_IP, } = useProps() || {};
+    const ips = typeof ip === 'string' ? ip.split(',') : ip;
+    useServerPlugin(() => {
+        const action = useAction();
+        if (!action.clientIp || (ips === null || ips === void 0 ? void 0 : ips.includes(action.clientIp))) {
+            return children;
+        }
+    });
+}
+
+export { blacklist };

package/plugins/utils/blacklist/blacklist.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+var useServerPlugin = require('../../../hooks/useServerPlugin/useServerPlugin.js');
+var useAction = require('../../../hooks/useAction/useAction.js');
+
+function blacklist() {
+    const { children, ip = process.env.INNET_BLACKLIST_IP, } = jsx.useProps() || {};
+    const ips = typeof ip === 'string' ? ip.split(',') : ip;
+    useServerPlugin.useServerPlugin(() => {
+        const action = useAction.useAction();
+        if (!action.clientIp || (ips === null || ips === void 0 ? void 0 : ips.includes(action.clientIp))) {
+            return children;
+        }
+    });
+}
+
+exports.blacklist = blacklist;

package/plugins/utils/blacklist/index.d.ts

@@ -0,0 +1 @@
+export * from './blacklist';

package/plugins/utils/blacklist/index.es6.js

@@ -0,0 +1 @@
+export { blacklist } from './blacklist.es6.js';

package/plugins/utils/blacklist/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var blacklist = require('./blacklist.js');
+
+
+
+exports.blacklist = blacklist.blacklist;

package/plugins/utils/dts/dts.d.ts

@@ -1,5 +1,6 @@
 import { type HandlerPlugin } from 'innet';
 export interface DtsProps {
-    path: string;
+    namespace?: string;
+    path?: string;
 }
 export declare const dts: HandlerPlugin;

package/plugins/utils/dts/dts.es6.js

@@ -6,9 +6,9 @@ import { useApi } from '../../../hooks/useApi/useApi.es6.js';
 import { generateTypes } from '../../../utils/generateTypes/generateTypes.es6.js';
 
 const dts = () => {
-    const { path } = useProps();
+    const { namespace = process.env.INNET_DTS_NAMESPACE, path = process.env.INNET_DTS_PATH || 'src/apiTypes.d.ts', } = useProps() || {};
     const { docs } = useApi();
-    promises.writeFile(path, generateTypes(docs)).catch(e => {
+    promises.writeFile(path, generateTypes(docs, namespace)).catch(e => {
         console.error(e);
     });
 };

package/plugins/utils/dts/dts.js

@@ -10,9 +10,9 @@ var useApi = require('../../../hooks/useApi/useApi.js');
 var generateTypes = require('../../../utils/generateTypes/generateTypes.js');
 
 const dts = () => {
-    const { path } = jsx.useProps();
+    const { namespace = process.env.INNET_DTS_NAMESPACE, path = process.env.INNET_DTS_PATH || 'src/apiTypes.d.ts', } = jsx.useProps() || {};
     const { docs } = useApi.useApi();
-    fs.promises.writeFile(path, generateTypes.generateTypes(docs)).catch(e => {
+    fs.promises.writeFile(path, generateTypes.generateTypes(docs, namespace)).catch(e => {
         console.error(e);
     });
 };

package/plugins/utils/env/env.d.ts

@@ -0,0 +1,7 @@
+import { type HandlerPlugin } from 'innet';
+export interface EnvProps {
+    children?: any;
+    is: string | string[];
+    of?: string;
+}
+export declare const env: HandlerPlugin;

package/plugins/utils/env/env.es6.js

@@ -0,0 +1,11 @@
+import innet, { useHandler } from 'innet';
+import { useProps } from '@innet/jsx';
+
+const env = () => {
+    const { children, is, of = 'NODE_ENV', } = useProps();
+    if (Array.isArray(is) ? is.includes(process.env[of]) : process.env[of] === is) {
+        innet(children, useHandler());
+    }
+};
+
+export { env };

package/plugins/utils/{prod/prod.js → env/env.js}

@@ -9,10 +9,11 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
 
-const prod = () => {
-    if (process.env.NODE_ENV === 'production') {
-        innet__default["default"](jsx.useChildren(), innet.useHandler());
+const env = () => {
+    const { children, is, of = 'NODE_ENV', } = jsx.useProps();
+    if (Array.isArray(is) ? is.includes(process.env[of]) : process.env[of] === is) {
+        innet__default["default"](children, innet.useHandler());
     }
 };
 
-exports.prod = prod;
+exports.env = env;

package/plugins/utils/env/index.d.ts

@@ -0,0 +1 @@
+export * from './env';

package/plugins/utils/env/index.es6.js

@@ -0,0 +1 @@
+export { env } from './env.es6.js';

package/plugins/utils/{dev → env}/index.js

@@ -2,8 +2,8 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var dev = require('./dev.js');
+var env = require('./env.js');
 
 
 
-exports.dev = dev.dev;
+exports.env = env.env;

package/plugins/utils/index.d.ts

@@ -1,5 +1,6 @@
 export * from './swagger';
 export * from './dts';
-export * from './dev';
-export * from './prod';
+export * from './env';
 export * from './protection';
+export * from './blacklist';
+export * from './whitelist';

package/plugins/utils/index.es6.js

@@ -1,5 +1,6 @@
 import './swagger/index.es6.js';
 import './dts/index.es6.js';
-import './dev/index.es6.js';
-import './prod/index.es6.js';
+import './env/index.es6.js';
 import './protection/index.es6.js';
+import './blacklist/index.es6.js';
+import './whitelist/index.es6.js';

package/plugins/utils/index.js

@@ -2,7 +2,8 @@
 
 require('./swagger/index.js');
 require('./dts/index.js');
-require('./dev/index.js');
-require('./prod/index.js');
+require('./env/index.js');
 require('./protection/index.js');
+require('./blacklist/index.js');
+require('./whitelist/index.js');