@oliasoft-open-source/node-json-migrator 3.0.0-beta-4 → 3.0.0-beta-6

package/dist/index.cjs

@@ -2,8 +2,6 @@
 
 var path$1 = require('path');
 var fs = require('fs');
-var ajv$1 = require('ajv');
-var ajvErrors = require('ajv-errors');
 var moduleFromString = require('module-from-string');
 var crypto = require('crypto');
 var node_url = require('node:url');
@@ -2079,42 +2077,190 @@ var xor = baseRest(function(arrays) {
   return baseXor(arrayFilter(arrays, isArrayLikeObject));
 });
 
-var type = "array";
-var items = {
-	type: "object",
-	properties: {
-		fileHash: {
-			type: [
-				"string"
-			]
-		},
-		fileName: {
-			type: "string"
-		},
-		sequence: {
-			type: "string",
-			pattern: "^[1-9][0-9]*(.[1-9][0-9]*)*$"
-		}
-	},
-	required: [
-		"fileHash",
-		"fileName",
-		"sequence"
-	],
-	additionalProperties: false
-};
-var planSchema = {
-	type: type,
-	items: items
+const planSchemaValidator = validate14;
+const schema32 = {
+  items: {
+    properties: {
+      fileHash: { type: ["string"] }}}
 };
+const pattern0 = new RegExp("^[1-9][0-9]*(.[1-9][0-9]*)*$", "u");
+function validate14(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (Array.isArray(data)) {
+    const len0 = data.length;
+    for (let i0 = 0; i0 < len0; i0++) {
+      let data0 = data[i0];
+      if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+        if (data0.fileHash === void 0) {
+          const err0 = {
+            instancePath: instancePath + "/" + i0,
+            schemaPath: "#/items/required",
+            keyword: "required",
+            params: { missingProperty: "fileHash" },
+            message: "must have required property 'fileHash'"
+          };
+          if (vErrors === null) {
+            vErrors = [err0];
+          } else {
+            vErrors.push(err0);
+          }
+          errors++;
+        }
+        if (data0.fileName === void 0) {
+          const err1 = {
+            instancePath: instancePath + "/" + i0,
+            schemaPath: "#/items/required",
+            keyword: "required",
+            params: { missingProperty: "fileName" },
+            message: "must have required property 'fileName'"
+          };
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+        if (data0.sequence === void 0) {
+          const err2 = {
+            instancePath: instancePath + "/" + i0,
+            schemaPath: "#/items/required",
+            keyword: "required",
+            params: { missingProperty: "sequence" },
+            message: "must have required property 'sequence'"
+          };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+        for (const key0 in data0) {
+          if (!(key0 === "fileHash" || key0 === "fileName" || key0 === "sequence")) {
+            const err3 = {
+              instancePath: instancePath + "/" + i0,
+              schemaPath: "#/items/additionalProperties",
+              keyword: "additionalProperties",
+              params: { additionalProperty: key0 },
+              message: "must NOT have additional properties"
+            };
+            if (vErrors === null) {
+              vErrors = [err3];
+            } else {
+              vErrors.push(err3);
+            }
+            errors++;
+          }
+        }
+        if (data0.fileHash !== void 0) {
+          if (typeof data0.fileHash !== "string") {
+            const err4 = {
+              instancePath: instancePath + "/" + i0 + "/fileHash",
+              schemaPath: "#/items/properties/fileHash/type",
+              keyword: "type",
+              params: { type: schema32.items.properties.fileHash.type },
+              message: "must be string"
+            };
+            if (vErrors === null) {
+              vErrors = [err4];
+            } else {
+              vErrors.push(err4);
+            }
+            errors++;
+          }
+        }
+        if (data0.fileName !== void 0) {
+          if (typeof data0.fileName !== "string") {
+            const err5 = {
+              instancePath: instancePath + "/" + i0 + "/fileName",
+              schemaPath: "#/items/properties/fileName/type",
+              keyword: "type",
+              params: { type: "string" },
+              message: "must be string"
+            };
+            if (vErrors === null) {
+              vErrors = [err5];
+            } else {
+              vErrors.push(err5);
+            }
+            errors++;
+          }
+        }
+        if (data0.sequence !== void 0) {
+          let data3 = data0.sequence;
+          if (typeof data3 === "string") {
+            if (!pattern0.test(data3)) {
+              const err6 = {
+                instancePath: instancePath + "/" + i0 + "/sequence",
+                schemaPath: "#/items/properties/sequence/pattern",
+                keyword: "pattern",
+                params: { pattern: "^[1-9][0-9]*(.[1-9][0-9]*)*$" },
+                message: 'must match pattern "^[1-9][0-9]*(.[1-9][0-9]*)*$"'
+              };
+              if (vErrors === null) {
+                vErrors = [err6];
+              } else {
+                vErrors.push(err6);
+              }
+              errors++;
+            }
+          } else {
+            const err7 = {
+              instancePath: instancePath + "/" + i0 + "/sequence",
+              schemaPath: "#/items/properties/sequence/type",
+              keyword: "type",
+              params: { type: "string" },
+              message: "must be string"
+            };
+            if (vErrors === null) {
+              vErrors = [err7];
+            } else {
+              vErrors.push(err7);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err8 = {
+          instancePath: instancePath + "/" + i0,
+          schemaPath: "#/items/type",
+          keyword: "type",
+          params: { type: "object" },
+          message: "must be object"
+        };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err9 = {
+      instancePath,
+      schemaPath: "#/type",
+      keyword: "type",
+      params: { type: "array" },
+      message: "must be array"
+    };
+    if (vErrors === null) {
+      vErrors = [err9];
+    } else {
+      vErrors.push(err9);
+    }
+    errors++;
+  }
+  validate14.errors = vErrors;
+  return errors === 0;
+}
 
 const isNonEmptyString = (input) => isString(input) && input.length > 0;
-const ajv = new ajv$1.Ajv({ allErrors: true });
-ajvErrors(ajv);
-const planValidator = ajv.compile(planSchema);
 const validatePlan = (plan) => {
-  const valid = planValidator(plan);
-  const { errors } = planValidator;
+  const valid = planSchemaValidator(plan);
+  const errors = planSchemaValidator.errors;
   if (errors?.length) {
     errors.forEach(
       (e) => console.error(

package/dist/index.mjs

@@ -1,7 +1,5 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import path$1 from 'path';
 import { realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$1, lstatSync, promises } from 'fs';
-import { Ajv } from 'ajv';
-import ajvErrors from 'ajv-errors';
 import { importFromString } from 'module-from-string';
 import { createHash } from 'crypto';
 import { fileURLToPath } from 'node:url';
@@ -2058,42 +2056,190 @@ var xor = baseRest(function(arrays) {
   return baseXor(arrayFilter(arrays, isArrayLikeObject));
 });
 
-var type = "array";
-var items = {
-	type: "object",
-	properties: {
-		fileHash: {
-			type: [
-				"string"
-			]
-		},
-		fileName: {
-			type: "string"
-		},
-		sequence: {
-			type: "string",
-			pattern: "^[1-9][0-9]*(.[1-9][0-9]*)*$"
-		}
-	},
-	required: [
-		"fileHash",
-		"fileName",
-		"sequence"
-	],
-	additionalProperties: false
-};
-var planSchema = {
-	type: type,
-	items: items
+const planSchemaValidator = validate14;
+const schema32 = {
+  items: {
+    properties: {
+      fileHash: { type: ["string"] }}}
 };
+const pattern0 = new RegExp("^[1-9][0-9]*(.[1-9][0-9]*)*$", "u");
+function validate14(data, { instancePath = "", parentData, parentDataProperty, rootData = data } = {}) {
+  let vErrors = null;
+  let errors = 0;
+  if (Array.isArray(data)) {
+    const len0 = data.length;
+    for (let i0 = 0; i0 < len0; i0++) {
+      let data0 = data[i0];
+      if (data0 && typeof data0 == "object" && !Array.isArray(data0)) {
+        if (data0.fileHash === void 0) {
+          const err0 = {
+            instancePath: instancePath + "/" + i0,
+            schemaPath: "#/items/required",
+            keyword: "required",
+            params: { missingProperty: "fileHash" },
+            message: "must have required property 'fileHash'"
+          };
+          if (vErrors === null) {
+            vErrors = [err0];
+          } else {
+            vErrors.push(err0);
+          }
+          errors++;
+        }
+        if (data0.fileName === void 0) {
+          const err1 = {
+            instancePath: instancePath + "/" + i0,
+            schemaPath: "#/items/required",
+            keyword: "required",
+            params: { missingProperty: "fileName" },
+            message: "must have required property 'fileName'"
+          };
+          if (vErrors === null) {
+            vErrors = [err1];
+          } else {
+            vErrors.push(err1);
+          }
+          errors++;
+        }
+        if (data0.sequence === void 0) {
+          const err2 = {
+            instancePath: instancePath + "/" + i0,
+            schemaPath: "#/items/required",
+            keyword: "required",
+            params: { missingProperty: "sequence" },
+            message: "must have required property 'sequence'"
+          };
+          if (vErrors === null) {
+            vErrors = [err2];
+          } else {
+            vErrors.push(err2);
+          }
+          errors++;
+        }
+        for (const key0 in data0) {
+          if (!(key0 === "fileHash" || key0 === "fileName" || key0 === "sequence")) {
+            const err3 = {
+              instancePath: instancePath + "/" + i0,
+              schemaPath: "#/items/additionalProperties",
+              keyword: "additionalProperties",
+              params: { additionalProperty: key0 },
+              message: "must NOT have additional properties"
+            };
+            if (vErrors === null) {
+              vErrors = [err3];
+            } else {
+              vErrors.push(err3);
+            }
+            errors++;
+          }
+        }
+        if (data0.fileHash !== void 0) {
+          if (typeof data0.fileHash !== "string") {
+            const err4 = {
+              instancePath: instancePath + "/" + i0 + "/fileHash",
+              schemaPath: "#/items/properties/fileHash/type",
+              keyword: "type",
+              params: { type: schema32.items.properties.fileHash.type },
+              message: "must be string"
+            };
+            if (vErrors === null) {
+              vErrors = [err4];
+            } else {
+              vErrors.push(err4);
+            }
+            errors++;
+          }
+        }
+        if (data0.fileName !== void 0) {
+          if (typeof data0.fileName !== "string") {
+            const err5 = {
+              instancePath: instancePath + "/" + i0 + "/fileName",
+              schemaPath: "#/items/properties/fileName/type",
+              keyword: "type",
+              params: { type: "string" },
+              message: "must be string"
+            };
+            if (vErrors === null) {
+              vErrors = [err5];
+            } else {
+              vErrors.push(err5);
+            }
+            errors++;
+          }
+        }
+        if (data0.sequence !== void 0) {
+          let data3 = data0.sequence;
+          if (typeof data3 === "string") {
+            if (!pattern0.test(data3)) {
+              const err6 = {
+                instancePath: instancePath + "/" + i0 + "/sequence",
+                schemaPath: "#/items/properties/sequence/pattern",
+                keyword: "pattern",
+                params: { pattern: "^[1-9][0-9]*(.[1-9][0-9]*)*$" },
+                message: 'must match pattern "^[1-9][0-9]*(.[1-9][0-9]*)*$"'
+              };
+              if (vErrors === null) {
+                vErrors = [err6];
+              } else {
+                vErrors.push(err6);
+              }
+              errors++;
+            }
+          } else {
+            const err7 = {
+              instancePath: instancePath + "/" + i0 + "/sequence",
+              schemaPath: "#/items/properties/sequence/type",
+              keyword: "type",
+              params: { type: "string" },
+              message: "must be string"
+            };
+            if (vErrors === null) {
+              vErrors = [err7];
+            } else {
+              vErrors.push(err7);
+            }
+            errors++;
+          }
+        }
+      } else {
+        const err8 = {
+          instancePath: instancePath + "/" + i0,
+          schemaPath: "#/items/type",
+          keyword: "type",
+          params: { type: "object" },
+          message: "must be object"
+        };
+        if (vErrors === null) {
+          vErrors = [err8];
+        } else {
+          vErrors.push(err8);
+        }
+        errors++;
+      }
+    }
+  } else {
+    const err9 = {
+      instancePath,
+      schemaPath: "#/type",
+      keyword: "type",
+      params: { type: "array" },
+      message: "must be array"
+    };
+    if (vErrors === null) {
+      vErrors = [err9];
+    } else {
+      vErrors.push(err9);
+    }
+    errors++;
+  }
+  validate14.errors = vErrors;
+  return errors === 0;
+}
 
 const isNonEmptyString = (input) => isString(input) && input.length > 0;
-const ajv = new Ajv({ allErrors: true });
-ajvErrors(ajv);
-const planValidator = ajv.compile(planSchema);
 const validatePlan = (plan) => {
-  const valid = planValidator(plan);
-  const { errors } = planValidator;
+  const valid = planSchemaValidator(plan);
+  const errors = planSchemaValidator.errors;
   if (errors?.length) {
     errors.forEach(
       (e) => console.error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oliasoft-open-source/node-json-migrator",
-  "version": "3.0.0-beta-4",
+  "version": "3.0.0-beta-6",
   "description": "A library for JSON migrations",
   "homepage": "https://oliasoft-open-source.gitlab.io/node-postgresql-migrator",
   "bugs": {
@@ -31,6 +31,7 @@
   ],
   "scripts": {
     "build": "pkgroll --clean-dist",
+    "compile:validators": "tsx scripts/compile-validators.ts",
     "lint:check": "npx eslint '**/*.{js,ts,json}'",
     "lint:fix": "npx eslint --fix '**/*.{js,ts,json}'",
     "prepare": "husky",
@@ -74,8 +75,6 @@
     "typescript-eslint": "^8.26.1"
   },
   "peerDependencies": {
-    "ajv": "^8",
-    "ajv-errors": "^3",
     "pg-promise": "^10||^11"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"