@amritk/generate-validators 0.15.0 → 0.15.1

package/dist/generators/generate-validator-function.js

@@ -1,6 +1,7 @@
 import { regexFlagsFor, regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive, MJST_EXTENSION_KEY } from "@amritk/helpers/mjst-extension";
 import { multipleOfFailExpr, multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
+import { boundFailExpr, boundOperator, boundPassExpr } from "@amritk/helpers/numeric-bound-check";
 import { declaresKey, readKey } from "@amritk/helpers/read-key";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { safeAccessor } from "@amritk/helpers/safe-accessor";
@@ -338,25 +339,23 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
   if (hasMinimum(propSchema) || hasMaximum(propSchema) || hasExclusiveMinimum(propSchema) || hasExclusiveMaximum(propSchema) || hasMultipleOf(propSchema)) {
     if (hasMinimum(propSchema)) {
       const strict = hasStrictExclusiveMinimum(propSchema);
-      const rel = strict ? ">" : ">=";
-      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} ${rel} ${propSchema.minimum})) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be ${rel} ${propSchema.minimum}', path: ${path} })`);
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "minimum", propSchema.minimum, strict)}) {`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be ${boundOperator("minimum", strict)} ${propSchema.minimum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasMaximum(propSchema)) {
       const strict = hasStrictExclusiveMaximum(propSchema);
-      const rel = strict ? "<" : "<=";
-      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} ${rel} ${propSchema.maximum})) {`);
-      lines.push(`    ${ctx.sink}.push({ message: 'must be ${rel} ${propSchema.maximum}', path: ${path} })`);
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "maximum", propSchema.maximum, strict)}) {`);
+      lines.push(`    ${ctx.sink}.push({ message: 'must be ${boundOperator("maximum", strict)} ${propSchema.maximum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasExclusiveMinimum(propSchema)) {
-      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} > ${propSchema.exclusiveMinimum})) {`);
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "minimum", propSchema.exclusiveMinimum, true)}) {`);
       lines.push(`    ${ctx.sink}.push({ message: 'must be > ${propSchema.exclusiveMinimum}', path: ${path} })`);
       lines.push(`  }`);
     }
     if (hasExclusiveMaximum(propSchema)) {
-      lines.push(`  if (typeof ${raw} === 'number' && !(${raw} < ${propSchema.exclusiveMaximum})) {`);
+      lines.push(`  if (typeof ${raw} === 'number' && ${boundFailExpr(raw, "maximum", propSchema.exclusiveMaximum, true)}) {`);
       lines.push(`    ${ctx.sink}.push({ message: 'must be < ${propSchema.exclusiveMaximum}', path: ${path} })`);
       lines.push(`  }`);
     }
@@ -1070,13 +1069,13 @@ const booleanLeafExpr = (schema, acc, narrowable = true) => {
       if (t === "integer")
         parts.push(`Number.isInteger(${acc})`);
       if (hasMinimum(schema))
-        parts.push(`${num} ${hasStrictExclusiveMinimum(schema) ? ">" : ">="} ${schema.minimum}`);
+        parts.push(boundPassExpr(num, "minimum", schema.minimum, hasStrictExclusiveMinimum(schema)));
       if (hasMaximum(schema))
-        parts.push(`${num} ${hasStrictExclusiveMaximum(schema) ? "<" : "<="} ${schema.maximum}`);
+        parts.push(boundPassExpr(num, "maximum", schema.maximum, hasStrictExclusiveMaximum(schema)));
       if (hasExclusiveMinimum(schema))
-        parts.push(`${num} > ${schema.exclusiveMinimum}`);
+        parts.push(boundPassExpr(num, "minimum", schema.exclusiveMinimum, true));
       if (hasExclusiveMaximum(schema))
-        parts.push(`${num} < ${schema.exclusiveMaximum}`);
+        parts.push(boundPassExpr(num, "maximum", schema.exclusiveMaximum, true));
       if (hasMultipleOf(schema))
         parts.push(multipleOfPassExpr(num, schema.multipleOf));
       return withMembership(parts.join(" && "));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -55,10 +55,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.17.0"
+    "@amritk/helpers": "^0.18.0"
   },
   "devDependencies": {
-    "@amritk/runtime-validators": "^0.12.1",
+    "@amritk/runtime-validators": "^0.13.0",
     "@ryoppippi/unplugin-typia": "^2.6.5",
     "@scalar/openapi-parser": "^0.26.1",
     "@sinclair/typebox": "^0.34.49",