fix: standalone validation code, tests (fixes #88)

Author: epoberezkin

package.json

@@ -11,8 +11,8 @@
   "scripts": {
     "build": "rm -rf dist && tsc",
     "eslint": "eslint \"src/**/*.*s\" \"spec/**/*.*s\"",
-    "prettier:write": "prettier --write \"./**/*.{md,json,ts,js}\"",
-    "prettier:check": "prettier --list-different \"./**/*.{md,json,ts,js}\"",
+    "prettier:write": "prettier --write \"./**/*.{json,ts,js}\"",
+    "prettier:check": "prettier --list-different \"./**/*.{json,ts,js}\"",
     "test-spec": "jest \"spec/*.ts\"",
     "test-cov": "jest \"spec/*.ts\" --coverage",
     "test": "npm run prettier:check && npm run eslint && npm run build && npm run test-cov",
@@ -50,7 +50,6 @@
     "husky": "^4.3.0",
     "jest": "^26.6.3",
     "lint-staged": "^10.5.1",
-    "pre-commit": "^1.2.2",
     "prettier": "^2.1.2",
     "ts-jest": "^26.4.4",
     "typescript": "^4.0.5"
@@ -62,6 +61,6 @@
     }
   },
   "lint-staged": {
-    "*.{md,json,yaml,js,ts}": "prettier --write"
+    "*.{json,yaml,js,ts}": "prettier --write"
   }
 }

spec/object.spec.ts

@@ -1,15 +1,17 @@
 import ajvErrors from ".."
 import Ajv, {SchemaObject, ErrorObject, ValidateFunction} from "ajv"
+import AjvPack from "ajv/dist/standalone/instance"
 import assert = require("assert")
 
+function _ajv(verbose?: boolean): Ajv {
+  return ajvErrors(new Ajv({allErrors: true, verbose, code: {source: true}}))
+}
+
 describe("errorMessage value is an object", () => {
-  let ajvs: Ajv[]
+  let ajvs: (Ajv | AjvPack)[]
 
   beforeEach(() => {
-    ajvs = [
-      ajvErrors(new Ajv({allErrors: true})),
-      ajvErrors(new Ajv({allErrors: true, verbose: true})),
-    ]
+    ajvs = [_ajv(), _ajv(true), new AjvPack(_ajv()), new AjvPack(_ajv(true))]
   })
 
   describe("keywords", () => {
@@ -50,7 +52,10 @@ describe("errorMessage value is an object", () => {
               assert.strictEqual(err.dataPath, "")
               assert.strictEqual(err.schemaPath, "#/errorMessage")
               const replacedKeywords = err.params.errors.map((e: ErrorObject) => e.keyword)
-              assert.deepStrictEqual(replacedKeywords.sort(), expectedErr.sort())
+              assert.deepStrictEqual(
+                Array.from(replacedKeywords.sort()),
+                Array.from(expectedErr.sort())
+              )
             } else {
               // original error
               assert.strictEqual(err.keyword, expectedErr)
@@ -134,7 +139,10 @@ describe("errorMessage value is an object", () => {
             assert.strictEqual(err.dataPath, "/foo")
             assert.strictEqual(err.schemaPath, "#/properties/foo/errorMessage")
             const replacedKeywords = err.params.errors.map((e: ErrorObject) => e.keyword)
-            assert.deepStrictEqual(replacedKeywords.sort(), expectedErr.sort())
+            assert.deepStrictEqual(
+              Array.from(replacedKeywords.sort()),
+              Array.from(expectedErr.sort())
+            )
           } else {
             // original error
             assert.strictEqual(err.keyword, expectedErr)
@@ -281,7 +289,10 @@ describe("errorMessage value is an object", () => {
             assert.strictEqual(err.dataPath, "")
             assert.strictEqual(err.schemaPath, "#/errorMessage")
             const replacedKeywords = err.params.errors.map((e: ErrorObject) => e.keyword)
-            assert.deepStrictEqual(replacedKeywords, Object.keys(expectedErr))
+            assert.deepStrictEqual(
+              Array.from(replacedKeywords),
+              Array.from(Object.keys(expectedErr))
+            )
           } else {
             // original error
             assert.strictEqual(err.keyword, expectedErr)
@@ -570,7 +581,10 @@ describe("errorMessage value is an object", () => {
           assert((Array.isArray(data) ? /^\/(0|1)$/ : /^\/(foo|bar)$/).test(err.dataPath))
           assert.strictEqual(err.schemaPath, "#/errorMessage")
           const replacedKeywords = err.params.errors.map((e: ErrorObject) => e.keyword)
-          assert.deepStrictEqual(replacedKeywords.sort(), expectedErr.sort())
+          assert.deepStrictEqual(
+            Array.from(replacedKeywords.sort()),
+            Array.from(expectedErr.sort())
+          )
         } else {
           // original error
           assert.strictEqual(err.keyword, expectedErr)
@@ -620,7 +634,10 @@ describe("errorMessage value is an object", () => {
                 : schema.errorMessage[expectedErr[0] === "required" ? "required" : "_"]
               assert.strictEqual(err.message, expectedMessage)
               const replacedKeywords = err.params.errors.map((e: ErrorObject) => e.keyword)
-              assert.deepStrictEqual(replacedKeywords.sort(), expectedErr.sort())
+              assert.deepStrictEqual(
+                Array.from(replacedKeywords.sort()),
+                Array.from(expectedErr.sort())
+              )
             } else {
               // original error
               assert.strictEqual(err.keyword, expectedErr)

spec/string.spec.ts

@@ -1,13 +1,15 @@
 import ajvErrors from ".."
 import Ajv, {ErrorObject} from "ajv"
+import AjvPack from "ajv/dist/standalone/instance"
 import assert = require("assert")
 
+function _ajv(verbose?: boolean): Ajv {
+  return ajvErrors(new Ajv({allErrors: true, verbose, code: {source: true}}))
+}
+
 describe("errorMessage value is a string", () => {
   it("should replace all errors with custom error message", () => {
-    const ajvs = [
-      ajvErrors(new Ajv({allErrors: true})),
-      ajvErrors(new Ajv({allErrors: true, verbose: true})),
-    ]
+    const ajvs = [_ajv(), _ajv(true), new AjvPack(_ajv()), new AjvPack(_ajv(true))]
 
     const schema = {
       type: "object",
@@ -40,7 +42,10 @@ describe("errorMessage value is a string", () => {
         const replacedKeywords = err.params.errors.map((e: ErrorObject) => {
           return e.keyword
         })
-        assert.deepStrictEqual(replacedKeywords.sort(), expectedReplacedKeywords.sort())
+        assert.deepStrictEqual(
+          Array.from(replacedKeywords.sort()),
+          Array.from(expectedReplacedKeywords.sort())
+        )
       }
     })
   })

src/index.ts

@@ -292,7 +292,10 @@ function errorMessage(options: ErrorMessageOptions): CodeKeywordDefinition {
             _`${err}.dataPath.indexOf(${dataPath}) === 0`
           ),
           () => {
-            const childRegex = gen.scopeValue("pattern", {ref: /^\/([^/]*)(?:\/|$)/})
+            const childRegex = gen.scopeValue("pattern", {
+              ref: /^\/([^/]*)(?:\/|$)/,
+              code: _`new RegExp("^\\\/([^/]*)(?:\\\/|$)")`,
+            })
             const matches = gen.const(
               "emMatches",
               _`${childRegex}.exec(${err}.dataPath.slice(${dataPath}.length))`