@amritk/generate-validators 0.11.1 → 0.11.2

package/dist/generators/collect-validator-imports.js

@@ -1,7 +1,7 @@
 import { refToFilename } from '@amritk/helpers/ref-to-filename';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasProperties, hasRef, } from '@amritk/helpers/schema-guards';
+import { hasRef } from '@amritk/helpers/schema-guards';
 /**
  * Generates an import statement for a single $ref, importing both the type
  * and the validator function from the ref's generated file.
@@ -10,7 +10,9 @@ const buildImport = (ref, suffix) => {
     const filename = refToFilename(ref);
     const typeName = refToName(ref, suffix);
     const validatorName = `validate${typeName}`;
-    return `import { type ${typeName}, ${validatorName} } from './${filename}'`;
+    // `.js` extension so the emitted import resolves under Node ESM (not just Bun);
+    // `./x.js` → sibling `x.ts` is the standard NodeNext form.
+    return `import { type ${typeName}, ${validatorName} } from './${filename}.js'`;
 };
 /**
  * Resolves the canonical filename for a ref, stripping `-or-reference` suffixes
@@ -21,46 +23,57 @@ const canonicalFilename = (ref) => {
     return refToFilename(base);
 };
 /**
- * Walks one level of the schema and yields all direct $ref strings that should
- * become imports: properties, additionalProperties, items, and union branches.
+ * Recursively walks a schema and yields every `$ref` the validator emitter can
+ * turn into a `validateX(...)` call, in traversal order. The emitter recurses
+ * into far more than properties/items/additionalProperties/top-level
+ * combinators: it also delegates for `patternProperties`, `propertyNames`,
+ * `if`/`then`/`else`, `contains`, `prefixItems`, `dependentSchemas`, `not`, and
+ * objects nested inside any combinator branch. A `$ref` reached by *any* of those
+ * paths must become an import, or the generated file references an undefined
+ * `validateX`. (Mirrors the parsers package's `collect-imports` traversal.)
  */
-const collectDirectRefs = (schema) => {
-    if (typeof schema === 'boolean' || schema === null)
-        return [];
-    const refs = [];
+const collectDirectRefs = (value, refs = []) => {
+    if (typeof value !== 'object' || value === null)
+        return refs;
+    if (Array.isArray(value)) {
+        for (const item of value)
+            collectDirectRefs(item, refs);
+        return refs;
+    }
+    const schema = value;
+    // A `$ref` is a leaf: the emitter delegates the whole value to the referenced
+    // validator, so record the ref and do not descend past it.
     if (hasRef(schema)) {
         refs.push(schema.$ref);
         return refs;
     }
-    const propSchemas = 'properties' in schema && typeof schema.properties === 'object' && schema.properties !== null
-        ? Object.values(schema.properties)
-        : [];
-    for (const prop of propSchemas) {
-        if (hasRef(prop))
-            refs.push(prop.$ref);
-        if (hasItems(prop) && hasRef(prop.items))
-            refs.push(prop.items.$ref);
-        if (hasAdditionalProperties(prop) && hasRef(prop.additionalProperties)) {
-            refs.push(prop.additionalProperties.$ref);
+    // Every keyword whose subschema(s) the emitter recurses into. `properties` and
+    // `patternProperties` hold subschemas as object *values*; the combinator/tuple
+    // keywords hold them in arrays; the rest are single subschemas. We deliberately
+    // do NOT descend into `$defs`/`definitions` — those are split into their own
+    // generated files, not inlined by this validator. `collectDirectRefs`
+    // self-guards on non-objects, so a keyword that is a boolean or missing is a
+    // harmless no-op.
+    const subSchemaMaps = ['properties', 'patternProperties'];
+    for (const mapKey of subSchemaMaps) {
+        const map = schema[mapKey];
+        if (typeof map === 'object' && map !== null && !Array.isArray(map)) {
+            for (const sub of Object.values(map))
+                collectDirectRefs(sub, refs);
         }
-        // Inline nested objects are validated recursively by the generator, so any
-        // $refs anywhere inside them must become imports as well.
-        if (hasProperties(prop))
-            refs.push(...collectDirectRefs(prop));
     }
-    if (hasItems(schema) && hasRef(schema.items)) {
-        refs.push(schema.items.$ref);
+    const singleSubSchemas = ['items', 'additionalProperties', 'propertyNames', 'contains', 'if', 'then', 'else', 'not'];
+    for (const key of singleSubSchemas) {
+        if (key in schema)
+            collectDirectRefs(schema[key], refs);
     }
-    if (hasAdditionalProperties(schema) && hasRef(schema.additionalProperties)) {
-        refs.push(schema.additionalProperties.$ref);
-    }
-    for (const branch of [
-        ...(hasOneOf(schema) ? schema.oneOf : []),
-        ...(hasAnyOf(schema) ? schema.anyOf : []),
-        ...(hasAllOf(schema) ? schema.allOf : []),
-    ]) {
-        if (hasRef(branch))
-            refs.push(branch.$ref);
+    const arraySubSchemas = ['oneOf', 'anyOf', 'allOf', 'prefixItems'];
+    for (const key of arraySubSchemas) {
+        const arr = schema[key];
+        if (Array.isArray(arr)) {
+            for (const sub of arr)
+                collectDirectRefs(sub, refs);
+        }
     }
     return refs;
 };

package/dist/generators/generate-files.js

@@ -35,12 +35,13 @@ export const generateValidatorFile = (schema, typeName, options) => {
     const typeDefinition = generateTypeDefinition(schema, typeName, { typeSuffix });
     const validatorFunction = generateValidatorFunction(schema, typeName, typeSuffix);
     const booleanGuard = generateBooleanGuard(schema, typeName, typeSuffix);
-    let result = `import type { ValidationResult, ValidationError } from './validation-result'\n`;
+    // `.js` extension so the relative import resolves under Node ESM, not only Bun.
+    let result = `import type { ValidationResult, ValidationError } from './validation-result.js'\n`;
     // `const` checks on object/array values call the runtime `valuesEqual` helper.
     // Only import it when the generated body actually uses it, so files without a
     // structural `const` do not carry an unused import.
     if (validatorFunction.includes('valuesEqual(')) {
-        result += `import { valuesEqual } from './validation-result'\n`;
+        result += `import { valuesEqual } from './validation-result.js'\n`;
     }
     for (const imp of refImports) {
         result += imp + '\n';

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

@@ -1,5 +1,6 @@
 import { escapeRegexPattern } from '@amritk/helpers/escape-regex-pattern';
 import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { multipleOfFailExpr, multipleOfPassExpr } from '@amritk/helpers/multiple-of-check';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { safeAccessor } from '@amritk/helpers/safe-accessor';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasDependentRequired, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasItems, hasMaxItems, hasMaximum, hasMaxLength, hasMinItems, hasMinimum, hasMinLength, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasPropertyNames, hasRef, hasRequired, hasStrictExclusiveMaximum, hasStrictExclusiveMinimum, hasType, hasUniqueItems, isObjectSchema, isSchemaObject, } from '@amritk/helpers/schema-guards';
@@ -53,6 +54,19 @@ const wrongTypeCondition = (accessor, type) => {
             return '';
     }
 };
+/**
+ * Returns the list of type names when a schema's `type` is an array (the JSON
+ * Schema multi-type / nullable idiom, e.g. `["string","null"]`), else `null`.
+ * `hasType` only recognises a *string* `type`, so without special handling a
+ * multi-type schema slips through every branch and emits NO check — not even a
+ * required-presence check. A multi-type is validated as the *disjunction* of its
+ * per-type checks (the value must match at least one).
+ */
+const getTypeArray = (schema) => {
+    if (!isSchemaObject(schema) || !('type' in schema) || !Array.isArray(schema.type))
+        return null;
+    return schema.type;
+};
 const createRootContext = () => ({ objVar: 'obj', pathPrefix: '${_path}', depth: 0, hoisted: [] });
 /**
  * Returns the `patternProperties` regex sources, or an empty array when the
@@ -147,7 +161,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
         const vName = validatorName(refToName(ref, suffix));
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else {`);
             lines.push(`    const _r = ${vName}(${raw}, ${path})`);
             lines.push(`    if (_r !== true) errors.push(..._r.errors)`);
@@ -166,7 +180,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     if (instanceOf) {
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
             lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
             lines.push(`  }`);
@@ -183,7 +197,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
     if (primitive) {
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
             lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
             lines.push(`  }`);
@@ -201,7 +215,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
         const msg = JSON.stringify(`must be ${JSON.stringify(propSchema.const)}`);
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else if (${mismatch}) {`);
             lines.push(`    errors.push({ message: ${msg}, path: ${path} })`);
             lines.push(`  }`);
@@ -219,16 +233,49 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
         const label = propSchema.enum.map((v) => JSON.stringify(v)).join(', ');
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else if (!(${allowed} as unknown[]).includes(${raw})) {`);
-            lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
             lines.push(`  }`);
         }
         else {
             lines.push(`  if (${raw} !== undefined && !(${allowed} as unknown[]).includes(${raw})) {`);
-            lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
+            lines.push(`  }`);
+        }
+        return lines;
+    }
+    // Multi-type / nullable property (array `type`, e.g. `["string","null"]`).
+    // `hasType` is false for an array `type`, so without this the property emits no
+    // check at all. The value is valid when it matches ANY listed type, i.e. an
+    // error is reported only when it is the wrong type for EVERY listed type; the
+    // required-presence check is still emitted so a missing required prop fails.
+    const typeArray = getTypeArray(propSchema);
+    if (typeArray) {
+        const allWrong = typeArray
+            .map((t) => wrongTypeCondition(raw, t))
+            .filter((c) => c !== '')
+            .map((c) => `(${c})`)
+            .join(' && ');
+        const label = typeArray.map((t) => typeofString(t)).join(' or ');
+        if (isRequired) {
+            lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
+            if (allWrong) {
+                lines.push(`  } else if (${allWrong}) {`);
+                lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
+            }
+            lines.push(`  }`);
+        }
+        else if (allWrong) {
+            lines.push(`  if (${raw} !== undefined && (${allWrong})) {`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must be ${label}`)}, path: ${path} })`);
             lines.push(`  }`);
         }
+        // Any sibling value constraints (e.g. `minLength` on a `["string","null"]`)
+        // still apply — each carries its own runtime-type guard, so it is a no-op for
+        // the values it does not target.
+        lines.push(...generateConstraintChecks(key, raw, path, propSchema, suffix, ctx));
         return lines;
     }
     // typed property
@@ -238,7 +285,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
         const typLabel = typeofString(t);
         if (isRequired) {
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             if (wrongType) {
                 lines.push(`  } else if (${wrongType}) {`);
                 lines.push(`    errors.push({ message: 'must be ${typLabel}', path: ${path} })`);
@@ -267,7 +314,7 @@ const generatePropertyChecks = (key, propSchema, isRequired, suffix, ctx) => {
         if (!hasType(propSchema) && isRequired) {
             // No `type` to anchor a missing-property check, so enforce presence here.
             lines.push(`  if (!(${JSON.stringify(key)} in ${ctx.objVar})) {`);
-            lines.push(`    errors.push({ message: "must have required property '${key}'", path: ${parentPath} })`);
+            lines.push(`    errors.push({ message: ${JSON.stringify(`must have required property '${key}'`)}, path: ${parentPath} })`);
             lines.push(`  } else {`);
             lines.push(...extraLines);
             lines.push(`  }`);
@@ -353,7 +400,7 @@ const generateConstraintChecks = (key, raw, path, propSchema, suffix, ctx) => {
             lines.push(`  }`);
         }
         if (hasMultipleOf(propSchema)) {
-            lines.push(`  if (typeof ${raw} === 'number' && ${raw} % ${propSchema.multipleOf} !== 0) {`);
+            lines.push(`  if (typeof ${raw} === 'number' && ${multipleOfFailExpr(raw, propSchema.multipleOf)}) {`);
             lines.push(`    errors.push({ message: 'must be a multiple of ${propSchema.multipleOf}', path: ${path} })`);
             lines.push(`  }`);
         }
@@ -496,7 +543,7 @@ const generateValueChecks = (key, raw, path, propSchema, suffix, ctx) => {
         const allowed = JSON.stringify(propSchema.enum);
         const label = propSchema.enum.map((v) => JSON.stringify(v)).join(', ');
         lines.push(`  if (${raw} !== undefined && !(${allowed} as unknown[]).includes(${raw})) {`);
-        lines.push(`    errors.push({ message: \`must be one of: ${label}\`, path: ${path} })`);
+        lines.push(`    errors.push({ message: ${JSON.stringify(`must be one of: ${label}`)}, path: ${path} })`);
         lines.push(`  }`);
         return lines;
     }
@@ -1098,7 +1145,7 @@ const booleanLeafExpr = (schema, acc) => {
             if (hasExclusiveMaximum(schema))
                 parts.push(`!(${acc} >= ${schema.exclusiveMaximum})`);
             if (hasMultipleOf(schema))
-                parts.push(`${acc} % ${schema.multipleOf} === 0`);
+                parts.push(multipleOfPassExpr(acc, schema.multipleOf));
             return parts.join(' && ');
         }
         case 'boolean':
@@ -1305,7 +1352,7 @@ const generateScalarValidator = (schema, typeName, suffix) => {
         return [
             `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
             `  if (!(${allowed} as unknown[]).includes(input)) {`,
-            `    return { valid: false, errors: [{ message: \`must be one of: ${label}\`, path: _path }] }`,
+            `    return { valid: false, errors: [{ message: ${JSON.stringify(`must be one of: ${label}`)}, path: _path }] }`,
             `  }`,
             `  return true`,
             `}`,
@@ -1327,31 +1374,48 @@ const generateScalarValidator = (schema, typeName, suffix) => {
             `}`,
         ].join('\n');
     }
+    // Top-level multi-type / nullable schema (array `type`, e.g. `["string","null"]`).
+    // `hasType` is false for an array `type`, so without this a root multi-type
+    // schema falls through to the final `return true` and validates NOTHING. The
+    // value is valid when it matches any listed type.
+    const rootTypeArray = getTypeArray(schema);
+    if (rootTypeArray) {
+        const allWrong = rootTypeArray
+            .map((t) => wrongTypeCondition('input', t))
+            .filter((c) => c !== '')
+            .map((c) => `(${c})`)
+            .join(' && ');
+        const label = rootTypeArray.map((t) => typeofString(t)).join(' or ');
+        if (!allWrong) {
+            return [
+                `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+                `  return true`,
+                `}`,
+            ].join('\n');
+        }
+        return [
+            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `  if (${allWrong}) {`,
+            `    return { valid: false, errors: [{ message: ${JSON.stringify(`must be ${label}`)}, path: _path }] }`,
+            `  }`,
+            `  return true`,
+            `}`,
+        ].join('\n');
+    }
     // Top-level typed schema (string, number, boolean, array)
     if (hasType(schema)) {
         const t = schema.type;
         const wrongType = wrongTypeCondition('input', t);
         const typLabel = typeofString(t);
-        const constraintLines = [];
-        if (t === 'string') {
-            if (hasPattern(schema)) {
-                const re = escapeRegexPattern(schema.pattern);
-                const msg = JSON.stringify(`must match pattern ${schema.pattern}`);
-                constraintLines.push(`  if (typeof input === 'string' && !/${re}/.test(input)) {`);
-                constraintLines.push(`    errors.push({ message: ${msg}, path: _path })`);
-                constraintLines.push(`  }`);
-            }
-            if (hasMinLength(schema)) {
-                constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`);
-                constraintLines.push(`    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`);
-                constraintLines.push(`  }`);
-            }
-            if (hasMaxLength(schema)) {
-                constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`);
-                constraintLines.push(`    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`);
-                constraintLines.push(`  }`);
-            }
-        }
+        // Reuse the shared constraint emitter — the per-property path already handles
+        // string (pattern, min/maxLength), number/integer (bounds, multipleOf) and
+        // array (items, min/maxItems, uniqueItems, contains, prefixItems). The root
+        // path previously only built string constraints, so a `{type:'number',
+        // minimum:5}` or `{type:'array', minItems:2}` root accepted invalid input.
+        // `raw` is `input`; `path` is the root `_path` (as a template so the shared
+        // emitter's `path.slice(1,-1)` for array-item indices still works).
+        const rootCtx = createRootContext();
+        const constraintLines = generateConstraintChecks('', 'input', '`${_path}`', schema, suffix, rootCtx);
         if (!wrongType) {
             return [
                 `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
@@ -1369,8 +1433,11 @@ const generateScalarValidator = (schema, typeName, suffix) => {
                 `}`,
             ].join('\n');
         }
+        // Array-item / nested constraints can hoist module-level declarations (e.g. a
+        // compiled known-keys set); emit them before the function so it references them.
+        const hoistedBlock = rootCtx.hoisted.length > 0 ? `${rootCtx.hoisted.join('\n')}\n\n` : '';
         return [
-            `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+            `${hoistedBlock}export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
             `  if (${wrongType}) {`,
             `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
             `  }`,
@@ -1382,6 +1449,44 @@ const generateScalarValidator = (schema, typeName, suffix) => {
     }
     return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join('\n');
 };
+/**
+ * Throws when a schema (anywhere in its subtree) uses a keyword this generator
+ * does not implement but which *narrows* the set of valid documents. Today that
+ * is `unevaluatedProperties` / `unevaluatedItems` with a constraining value
+ * (`false` or a subschema). The generator has no support for them — only the
+ * runtime interpreter does — so silently emitting a validator would produce one
+ * that ACCEPTS documents the interpreter REJECTS: a wrong verdict, worse than an
+ * error. `unevaluated*: true` is a no-op (it permits everything), so it is
+ * allowed through.
+ *
+ * We deliberately throw rather than implement the keywords: doing them correctly
+ * requires tracking which properties/items each combinator branch "evaluated",
+ * which is a large, separate feature. Failing loudly at generation time surfaces
+ * the gap instead of shipping a validator that lies.
+ */
+const assertNoUnsupportedKeywords = (schema, typeName) => {
+    const visit = (node) => {
+        if (typeof node !== 'object' || node === null)
+            return;
+        if (Array.isArray(node)) {
+            for (const item of node)
+                visit(item);
+            return;
+        }
+        const record = node;
+        for (const keyword of ['unevaluatedProperties', 'unevaluatedItems']) {
+            // `true` permits everything → no constraint → safe to ignore.
+            if (keyword in record && record[keyword] !== true) {
+                throw new Error(`[${typeName}] unsupported keyword "${keyword}": the validator generator does not implement it and would ` +
+                    `silently accept documents the interpreter rejects. Validate this schema with the runtime interpreter, ` +
+                    `or remove the keyword.`);
+            }
+        }
+        for (const value of Object.values(record))
+            visit(value);
+    };
+    visit(schema);
+};
 /**
  * Generates a TypeScript validator function from a JSON Schema.
  *
@@ -1405,6 +1510,7 @@ const generateScalarValidator = (schema, typeName, suffix) => {
  * ```
  */
 export const generateValidatorFunction = (schema, typeName, suffix = '') => {
+    assertNoUnsupportedKeywords(schema, typeName);
     if (isObjectSchema(schema)) {
         return generateObjectValidator(schema, typeName, suffix);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.11.1",
+  "version": "0.11.2",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -46,7 +46,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.10.1"
+    "@amritk/helpers": "0.10.2"
   },
   "devDependencies": {
     "@ryoppippi/unplugin-typia": "^2.6.5",