@arcblock/validator - npm Package Compare versions

Comparing version 1.16.16 to 1.16.17

lib/extension/bn.js

@@ -1,130 +0,137 @@
-const { BN } = require('@ocap/util');
-
-module.exports = (Joi) => ({
-  type: 'BN',
-  base: Joi.any(),
-  messages: {
-    'bn.nan': '{{#label}} is not a big number',
-    'bn.max': '{{#label}} needs to be less than or equal to "{{#threshold}}"',
-    'bn.min': '{{#label}} needs to be greater than or equal to "{{#threshold}}"',
-    'bn.less': '{{#label}} needs to be less than "{{#threshold}}"',
-    'bn.greater': '{{#label}} needs to be greater than "{{#threshold}}"',
-    'bn.positive': '{{#label}} needs to be positive',
-    'bn.negative': '{{#label}} needs to be negative',
-  },
-
-  prepare(value, helpers) {
-    try {
-      return { value: new BN(value) };
-    } catch (err) {
-      return { errors: helpers.error('bn.nan') };
-    }
-  },
-  coerce(value) {
-    return { value: value.toString(10) };
-  },
-
-  validate(value) {
-    return { value };
-  },
-
-  rules: {
-    gt: {
-      args: [
-        {
-          name: 'threshold',
-          ref: true,
-          assert: (v) => BN.isBN(v),
-          message: 'must be a big number',
-          normalize: (v) => new BN(v),
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BNExtension = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+function BNExtension(root) {
+    return {
+        type: 'BN',
+        base: root.any(),
+        messages: {
+            'bn.nan': '{{#label}} is not a big number',
+            'bn.max': '{{#label}} needs to be less than or equal to "{{#threshold}}"',
+            'bn.min': '{{#label}} needs to be greater than or equal to "{{#threshold}}"',
+            'bn.less': '{{#label}} needs to be less than "{{#threshold}}"',
+            'bn.greater': '{{#label}} needs to be greater than "{{#threshold}}"',
+            'bn.positive': '{{#label}} needs to be positive',
+            'bn.negative': '{{#label}} needs to be negative',
         },
-        {
-          name: 'equal',
-          assert: (v) => typeof v === 'boolean',
-          message: 'must be a boolean',
+        prepare(value, helpers) {
+            try {
+                return { value: new bn_js_1.default(value) };
+            }
+            catch (err) {
+                return { errors: helpers.error('bn.nan') };
+            }
         },
-      ],
-      // The rule return structure is different from the root
-      // eslint-disable-next-line consistent-return
-      validate(value, helpers, args) {
-        const v = new BN(value);
-        if (args.equal && v.lt(args.threshold)) {
-          return helpers.error('bn.min', args);
-        }
-        if (!args.equal && v.lte(args.threshold)) {
-          return helpers.error('bn.greater', args);
-        }
-
-        // must return value when valid
-        return value;
-      },
-    },
-
-    lt: {
-      args: [
-        {
-          name: 'threshold',
-          ref: true,
-          assert: (v) => BN.isBN(v),
-          message: 'must be a big number',
-          normalize: (v) => new BN(v),
+        coerce(value) {
+            return { value: value.toString(10) };
         },
-        {
-          name: 'equal',
-          assert: (v) => typeof v === 'boolean',
-          message: 'must be a boolean',
+        validate(value) {
+            return { value };
         },
-      ],
-      // The rule return structure is different from the root
-      // eslint-disable-next-line consistent-return
-      validate(value, helpers, args) {
-        const v = new BN(value);
-        if (args.equal && v.gt(args.threshold)) {
-          return helpers.error('bn.max', args);
-        }
-        if (!args.equal && v.gte(args.threshold)) {
-          return helpers.error('bn.less', args);
-        }
-
-        // must return value when valid
-        return value;
-      },
-    },
-
-    min: {
-      alias: 'gte',
-      method(threshold) {
-        return this.$_addRule({ name: 'gt', args: { threshold, equal: true } });
-      },
-    },
-    max: {
-      alias: 'lte',
-      method(threshold) {
-        return this.$_addRule({ name: 'lt', args: { threshold, equal: true } });
-      },
-    },
-    greater: {
-      alias: 'gt',
-      method(threshold) {
-        return this.$_addRule({ name: 'gt', args: { threshold, equal: false } });
-      },
-    },
-    less: {
-      alias: 'lt',
-      method(threshold) {
-        return this.$_addRule({ name: 'lt', args: { threshold, equal: false } });
-      },
-    },
-
-    positive: {
-      method() {
-        return this.$_addRule({ name: 'gt', args: { threshold: 0, equal: false } });
-      },
-    },
-    negative: {
-      method() {
-        return this.$_addRule({ name: 'lt', args: { threshold: 0, equal: false } });
-      },
-    },
-  },
-});
+        rules: {
+            gt: {
+                args: [
+                    {
+                        name: 'threshold',
+                        ref: true,
+                        assert: (v) => bn_js_1.default.isBN(v),
+                        message: 'must be a big number',
+                        normalize: (v) => new bn_js_1.default(v),
+                    },
+                    {
+                        name: 'equal',
+                        assert: (v) => typeof v === 'boolean',
+                        message: 'must be a boolean',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const v = new bn_js_1.default(value);
+                    if (args.equal && v.lt(args.threshold)) {
+                        return helpers.error('bn.min', args);
+                    }
+                    if (!args.equal && v.lte(args.threshold)) {
+                        return helpers.error('bn.greater', args);
+                    }
+                    // must return value when valid
+                    return value;
+                },
+            },
+            lt: {
+                args: [
+                    {
+                        name: 'threshold',
+                        ref: true,
+                        assert: (v) => bn_js_1.default.isBN(v),
+                        message: 'must be a big number',
+                        normalize: (v) => new bn_js_1.default(v),
+                    },
+                    {
+                        name: 'equal',
+                        assert: (v) => typeof v === 'boolean',
+                        message: 'must be a boolean',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const v = new bn_js_1.default(value);
+                    if (args.equal && v.gt(args.threshold)) {
+                        return helpers.error('bn.max', args);
+                    }
+                    if (!args.equal && v.gte(args.threshold)) {
+                        return helpers.error('bn.less', args);
+                    }
+                    // must return value when valid
+                    return value;
+                },
+            },
+            min: {
+                alias: 'gte',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold, equal: true } });
+                },
+            },
+            max: {
+                alias: 'lte',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold, equal: true } });
+                },
+            },
+            greater: {
+                alias: 'gt',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold, equal: false } });
+                },
+            },
+            less: {
+                alias: 'lt',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold, equal: false } });
+                },
+            },
+            positive: {
+                method() {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold: 0, equal: false } });
+                },
+            },
+            negative: {
+                method() {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold: 0, equal: false } });
+                },
+            },
+        },
+    };
+}
+exports.BNExtension = BNExtension;

lib/extension/did.js

@@ -1,100 +0,105 @@
-const isEqual = require('lodash/isEqual');
-const { types } = require('@ocap/mcrypto');
-const { isValid, toTypeInfo, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM } = require('@arcblock/did');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DIDExtension = void 0;
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const mcrypto_1 = require("@ocap/mcrypto");
+const did_1 = require("@arcblock/did");
 const ruleTypes = {
-  wallet: ['arcblock', 'ethereum', 'default', 'eth'],
-  pk: Object.keys(types.KeyType),
-  hash: Object.keys(types.HashType),
-  role: Object.keys(types.RoleType),
+    wallet: ['arcblock', 'ethereum', 'default', 'eth'],
+    pk: Object.keys(mcrypto_1.types.KeyType),
+    hash: Object.keys(mcrypto_1.types.HashType),
+    role: Object.keys(mcrypto_1.types.RoleType),
 };
-
-module.exports = (Joi) => ({
-  type: 'DID',
-  base: Joi.string().trim(),
-  messages: {
-    'did.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
-    'did.invalid': 'Expect {{#label}} to be valid did, got "{{#value}}"',
-    'did.wallet': 'Expect wallet type of {{#label}} to be "{{#expected}}" wallet, got "{{#actual}}"',
-    'did.pk': 'Expect pk type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
-    'did.hash': 'Expect hash type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
-    'did.role': 'Expect role type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
-  },
-
-  validate(value, helpers) {
-    if (!value || typeof value !== 'string') {
-      return { errors: helpers.error('did.empty', { value }) };
-    }
-
-    if (isValid(value) === false) {
-      return { errors: helpers.error('did.invalid', { value }) };
-    }
-
-    return { value };
-  },
-
-  rules: {
-    type: {
-      args: [
-        {
-          name: 'key',
-          ref: true,
-          assert: (v) => Object.keys(ruleTypes).includes(v),
-          message: `must be one of ${Object.keys(ruleTypes).join(', ')}`,
+function DIDExtension(root) {
+    return {
+        type: 'DID',
+        base: root.string().trim(),
+        messages: {
+            'did.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
+            'did.invalid': 'Expect {{#label}} to be valid did, got "{{#value}}"',
+            'did.wallet': 'Expect wallet type of {{#label}} to be "{{#expected}}" wallet, got "{{#actual}}"',
+            'did.pk': 'Expect pk type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.hash': 'Expect hash type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.role': 'Expect role type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
         },
-        {
-          name: 'expected',
-          assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
-          message: 'must be valid type',
+        validate(value, helpers) {
+            if (!value || typeof value !== 'string') {
+                return { errors: helpers.error('did.empty', { value }) };
+            }
+            if ((0, did_1.isValid)(value) === false) {
+                return { errors: helpers.error('did.invalid', { value }) };
+            }
+            return { value };
         },
-      ],
-      // The rule return structure is different from the root
-      // eslint-disable-next-line consistent-return
-      validate(value, helpers, args) {
-        const type = toTypeInfo(value);
-        const typeStr = toTypeInfo(value, true);
-
-        if (args.key === 'wallet') {
-          if (['ethereum', 'eth'].includes(args.expected) && isEqual(type, DID_TYPE_ETHEREUM) === false) {
-            return helpers.error('did.wallet', { ...args, actual: JSON.stringify(typeStr) });
-          }
-          if (['arcblock', 'default'].includes(args.expected) && isEqual(type, DID_TYPE_ARCBLOCK) === false) {
-            return helpers.error('did.wallet', { ...args, actual: JSON.stringify(typeStr) });
-          }
-        }
-        if (args.key === 'pk' && typeStr.pk !== args.expected) {
-          return helpers.error('did.pk', { ...args, actual: typeStr.pk });
-        }
-        if (args.key === 'hash' && typeStr.hash !== args.expected) {
-          return helpers.error('did.hash', { ...args, actual: typeStr.hash });
-        }
-        if (args.key === 'role' && typeStr.role !== args.expected) {
-          return helpers.error('did.role', { ...args, actual: typeStr.role });
-        }
-
-        return value;
-      },
-    },
-
-    wallet: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'wallet', expected: type } });
-      },
-    },
-    pk: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'pk', expected: type } });
-      },
-    },
-    hash: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'hash', expected: type } });
-      },
-    },
-    role: {
-      method(type) {
-        return this.$_addRule({ name: 'type', args: { key: 'role', expected: type } });
-      },
-    },
-  },
-});
+        rules: {
+            type: {
+                args: [
+                    {
+                        name: 'key',
+                        ref: true,
+                        assert: (v) => Object.keys(ruleTypes).includes(v),
+                        message: `must be one of ${Object.keys(ruleTypes).join(', ')}`,
+                    },
+                    {
+                        name: 'expected',
+                        // @ts-ignore
+                        assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
+                        message: 'must be valid type',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const type = (0, did_1.toTypeInfo)(value);
+                    const typeStr = (0, did_1.toTypeInfoStr)(value);
+                    if (args.key === 'wallet') {
+                        if (['ethereum', 'eth'].includes(args.expected) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ETHEREUM) === false) {
+                            return helpers.error('did.wallet', Object.assign(Object.assign({}, args), { actual: JSON.stringify(typeStr) }));
+                        }
+                        if (['arcblock', 'default'].includes(args.expected) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ARCBLOCK) === false) {
+                            return helpers.error('did.wallet', Object.assign(Object.assign({}, args), { actual: JSON.stringify(typeStr) }));
+                        }
+                    }
+                    if (args.key === 'pk' && typeStr.pk !== args.expected) {
+                        return helpers.error('did.pk', Object.assign(Object.assign({}, args), { actual: typeStr.pk }));
+                    }
+                    if (args.key === 'hash' && typeStr.hash !== args.expected) {
+                        return helpers.error('did.hash', Object.assign(Object.assign({}, args), { actual: typeStr.hash }));
+                    }
+                    if (args.key === 'role' && typeStr.role !== args.expected) {
+                        return helpers.error('did.role', Object.assign(Object.assign({}, args), { actual: typeStr.role }));
+                    }
+                    return value;
+                },
+            },
+            wallet: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'wallet', expected: type } });
+                },
+            },
+            pk: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'pk', expected: type } });
+                },
+            },
+            hash: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'hash', expected: type } });
+                },
+            },
+            role: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'role', expected: type } });
+                },
+            },
+        },
+    };
+}
+exports.DIDExtension = DIDExtension;

lib/index.js

@@ -1,51 +0,44 @@
-const JOI = require('joi');
-
-const bnExtension = require('./extension/bn');
-const didExtension = require('./extension/did');
-
-const Joi = JOI.extend(didExtension).extend(bnExtension);
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patterns = exports.schemas = exports.Joi = void 0;
+const joi_1 = __importDefault(require("joi"));
+const bn_1 = require("./extension/bn");
+const did_1 = require("./extension/did");
+exports.Joi = joi_1.default.extend(did_1.DIDExtension).extend(bn_1.BNExtension);
 const txHash = /^(0x)?([A-Fa-f0-9]{64})$/;
-
-const contextSchema = Joi.object({
-  genesisTime: Joi.date().iso().required().raw(),
-  genesisTx: Joi.string().regex(txHash).required().allow(''),
-  renaissanceTime: Joi.date().iso().required().raw(),
-  renaissanceTx: Joi.string().regex(txHash).required().allow(''),
+const contextSchema = exports.Joi.object({
+    genesisTime: exports.Joi.date().iso().required().raw(),
+    genesisTx: exports.Joi.string().regex(txHash).required().allow(''),
+    renaissanceTime: exports.Joi.date().iso().required().raw(),
+    renaissanceTx: exports.Joi.string().regex(txHash).required().allow(''),
 });
-
-const tokenInputSchema = Joi.object({
-  address: Joi.DID().role('ROLE_TOKEN').required(),
-  value: Joi.BN().positive().required(),
+const tokenInputSchema = exports.Joi.object({
+    address: exports.Joi.DID().role('ROLE_TOKEN').required(),
+    value: exports.Joi.BN().positive().required(),
 });
-
-const multiSigSchema = Joi.array().items({
-  signer: Joi.DID().required(),
-  pk: Joi.any().required(),
-  signature: Joi.any().required(),
-  delegator: Joi.DID().valid('').optional(),
-  data: Joi.any().optional(),
+const multiSigSchema = exports.Joi.array().items({
+    signer: exports.Joi.DID().required(),
+    pk: exports.Joi.any().required(),
+    signature: exports.Joi.any().required(),
+    delegator: exports.Joi.DID().valid('').optional(),
+    data: exports.Joi.any().optional(),
 });
-
-const foreignTokenSchema = Joi.object({
-  type: Joi.string().min(1).max(32).required(),
-  contractAddress: Joi.DID().wallet('ethereum').required(),
-  chainType: Joi.string().min(1).max(32).required(),
-  chainName: Joi.string().min(1).max(32).required(),
-  chainId: Joi.number().positive().required(),
+const foreignTokenSchema = exports.Joi.object({
+    type: exports.Joi.string().min(1).max(32).required(),
+    contractAddress: exports.Joi.DID().wallet('ethereum').required(),
+    chainType: exports.Joi.string().min(1).max(32).required(),
+    chainName: exports.Joi.string().min(1).max(32).required(),
+    chainId: exports.Joi.number().positive().required(),
 });
-
-const schemas = {
-  context: contextSchema,
-  tokenInput: tokenInputSchema,
-  multiSig: multiSigSchema,
-  foreignToken: foreignTokenSchema,
+exports.schemas = {
+    context: contextSchema,
+    tokenInput: tokenInputSchema,
+    multiSig: multiSigSchema,
+    foreignToken: foreignTokenSchema,
 };
-
-const patterns = {
-  txHash,
+exports.patterns = {
+    txHash,
 };
-
-module.exports = Joi;
-module.exports.schemas = schemas;
-module.exports.patterns = patterns;

package.json

@@ -6,5 +6,6 @@ {
   },
-  "version": "1.16.16",
+  "version": "1.16.17",
   "description": "",
   "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
   "files": [
@@ -14,16 +15,28 @@ "lib"
   "scripts": {
-    "lint": "eslint tests lib",
-    "lint:fix": "eslint --fix tests lib",
+    "lint": "eslint tests src",
+    "lint:fix": "eslint --fix tests src",
     "test": "jest --forceExit --detectOpenHandles",
-    "coverage": "npm run test -- --coverage"
+    "coverage": "npm run test -- --coverage",
+    "clean": "rm -fr lib",
+    "prebuild": "npm run clean",
+    "build:watch": "npm run build -- -w",
+    "build": "tsc"
   },
   "dependencies": {
-    "@arcblock/did": "1.16.16",
-    "@ocap/mcrypto": "1.16.16",
-    "@ocap/util": "1.16.16",
+    "@arcblock/did": "1.16.17",
+    "@ocap/mcrypto": "1.16.17",
+    "@ocap/util": "1.16.17",
+    "bn.js": "5.2.1",
     "joi": "^17.6.0",
     "lodash": "^4.17.21"
   },
+  "resolutions": {
+    "bn.js": "5.2.1"
+  },
   "devDependencies": {
-    "jest": "^27.3.1"
+    "@arcblock/eslint-config-ts": "0.2.2",
+    "eslint": "^8.17.0",
+    "jest": "^28.1.1",
+    "ts-jest": "^28.0.5",
+    "typescript": "^4.7.3"
   },
@@ -33,3 +46,3 @@ "keywords": [],
   "license": "MIT",
-  "gitHead": "051f9620995cf24407374cc4811b0fa6ed6dc7ca"
+  "gitHead": "489ce5e03bce27ddcd535390228b11ab56e7a2e3"
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

18382

increased by88.51%

Number of package files

9

increased by50%

Lines of code

454

increased by79.45%

Worsened metrics

Dependency count

6

increased by20%

Dev dependency count

5

increased by400%

Number of medium supply chain risk alerts

1

increased byInfinity%

Dependency changes

• + Addedbn.js@5.2.1

• + Added@arcblock/did@1.16.17(transitive)

• + Added@ocap/mcrypto@1.16.17(transitive)

• + Added@ocap/util@1.16.17(transitive)

• - Removed@arcblock/did@1.16.16(transitive)

• - Removed@ocap/mcrypto@1.16.16(transitive)

• - Removed@ocap/util@1.16.16(transitive)

• - Removedbn.js@5.2.0(transitive)

• Updated@arcblock/did@1.16.17

• Updated@ocap/mcrypto@1.16.17

• Updated@ocap/util@1.16.17