@amritk/generate-parsers 0.14.0 → 0.16.0

package/README.md

@@ -9,7 +9,7 @@
 ![license](https://img.shields.io/badge/license-MIT-22c55e?style=flat-square) 
 ![JSON Schema](https://img.shields.io/badge/JSON%20Schema-2020--12-f97316?style=flat-square) 
 ![node](https://img.shields.io/badge/node-%E2%89%A520-339933?style=flat-square&logo=node.js&logoColor=white) 
-![vibe coded](https://img.shields.io/badge/vibe%20coded-84%25-a855f7?style=flat-square)
+![vibe coded](https://img.shields.io/badge/vibe-coded-a855f7?style=flat-square)
 
 </div>
 
@@ -134,6 +134,14 @@ Returns: `Promise<GeneratedFile[]>`.
 <tr>
 <td colspan="3">Build each parser's result from the schema's declared properties only, silently dropping undeclared input keys at every nesting level (zod's .strip()). Extras are never a validation error, so this composes with strict (which still throws on wrong types and missing required properties) and yields to additionalProperties: false, which rejects rather than strips in strict mode.</td>
 </tr>
+<tr>
+<td>🔡 <code>caseInsensitive</code></td>
+<td><code>boolean</code></td>
+<td align="center"><code>false</code></td>
+</tr>
+<tr>
+<td colspan="3">Normalize a mis-cased string to the exact casing of a declared enum/const member it matches case-insensitively (e.g. hElLo → hello) instead of coercing to the default. Coerce mode only — strict parsers still reject a casing mismatch. Correctly-cased input keeps the exact-match fast path, so the hot path is unaffected.</td>
+</tr>
 </tbody>
 </table>
 <!-- config-table-end -->

package/dist/generators/build-schema.d.ts

@@ -48,8 +48,17 @@ export type GeneratedFile = {
  *   is used verbatim and is not affected by this suffix.
  * @param importExt - Extension used on every relative import specifier in the generated
  *   output (cross-file `$ref` imports, the index barrel, and embedded-helper imports).
- *   `'js'` (default) is the standard TS NodeNext form; `'ts'` emits the literal on-disk
- *   paths so the generated sources run directly under Node's type stripping.
+ *   `'js'` (this function's default) is the standard TS NodeNext form; `'ts'` emits the
+ *   literal on-disk paths so the generated sources run directly under Node's type
+ *   stripping. Note the `mjst` CLI defaults this to `'ts'` (falling back to `'js'` only
+ *   under `--build`, where tsc must compile the sources) so generated output runs under
+ *   Node without a build step; direct callers of `buildSchema` opt in explicitly.
+ * @param caseInsensitive - When true, the generated coercing parsers normalize a mis-cased
+ *   string to the exact casing of a declared `enum`/`const` member it matches
+ *   case-insensitively (e.g. `hElLo` → `hello`) instead of coercing to the default. Coerce
+ *   mode only — strict parsers still reject a casing mismatch. The normalization lives on
+ *   the coercion failure branch, so correctly-cased input keeps the exact-match fast path
+ *   and the hot path is unaffected.
  * @returns An array of generated TypeScript files
  *
  * @example
@@ -82,4 +91,4 @@ export type GeneratedFile = {
  * });
  * ```
  */
-export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, stripUnknown?: boolean, typeSuffix?: string, importExt?: ImportExtension) => Promise<GeneratedFile[]>;
+export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean, helpersMode?: HelpersMode, helpersImportPrefix?: string, readonly?: boolean, stripUnknown?: boolean, typeSuffix?: string, importExt?: ImportExtension, caseInsensitive?: boolean) => Promise<GeneratedFile[]>;

package/dist/generators/build-schema.js

@@ -84,8 +84,17 @@ const readHelperSource = async (helper, importExt) => {
  *   is used verbatim and is not affected by this suffix.
  * @param importExt - Extension used on every relative import specifier in the generated
  *   output (cross-file `$ref` imports, the index barrel, and embedded-helper imports).
- *   `'js'` (default) is the standard TS NodeNext form; `'ts'` emits the literal on-disk
- *   paths so the generated sources run directly under Node's type stripping.
+ *   `'js'` (this function's default) is the standard TS NodeNext form; `'ts'` emits the
+ *   literal on-disk paths so the generated sources run directly under Node's type
+ *   stripping. Note the `mjst` CLI defaults this to `'ts'` (falling back to `'js'` only
+ *   under `--build`, where tsc must compile the sources) so generated output runs under
+ *   Node without a build step; direct callers of `buildSchema` opt in explicitly.
+ * @param caseInsensitive - When true, the generated coercing parsers normalize a mis-cased
+ *   string to the exact casing of a declared `enum`/`const` member it matches
+ *   case-insensitively (e.g. `hElLo` → `hello`) instead of coercing to the default. Coerce
+ *   mode only — strict parsers still reject a casing mismatch. The normalization lives on
+ *   the coercion failure branch, so correctly-cased input keeps the exact-match fast path
+ *   and the hot path is unaffected.
  * @returns An array of generated TypeScript files
  *
  * @example
@@ -118,7 +127,7 @@ const readHelperSource = async (helper, importExt) => {
  * });
  * ```
  */
-export const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = 'package', helpersImportPrefix = './', readonly = false, stripUnknown = false, typeSuffix = '', importExt = 'js') => {
+export const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = 'package', helpersImportPrefix = './', readonly = false, stripUnknown = false, typeSuffix = '', importExt = 'js', caseInsensitive = false) => {
     const files = [];
     const usedHelpers = new Set();
     walkRefGraph(rootSchema, rootTypeName, { typeSuffix }, (node) => {
@@ -137,10 +146,12 @@ export const buildSchema = async (rootSchema, rootTypeName, extensions, typesOnl
             readonly,
             typeSuffix,
             importExt,
+            isRoot: node.isRoot,
             ...(node.ref !== undefined ? { selfRef: node.ref } : {}),
             ...(logWarnings !== undefined ? { logWarnings } : {}),
             ...(strict !== undefined ? { strict } : {}),
             ...(stripUnknown ? { stripUnknown } : {}),
+            ...(caseInsensitive ? { caseInsensitive } : {}),
         });
         files.push({ filename: `${node.filename}.ts`, content: result.content });
         for (const helper of result.usedHelpers)

package/dist/generators/generate-enum-check.d.ts

@@ -11,3 +11,20 @@
  * differs from `===`), so the verdict is unchanged.
  */
 export declare const generateEnumCheck: (accessor: string, enumValues: readonly unknown[]) => string;
+/**
+ * Builds a case-insensitive coercion expression for a string `enum`/`const`
+ * value whose exact-match check has already failed. Only the *string* members
+ * participate (a number/boolean/null member has no case to fold): a value that
+ * matches one case-insensitively normalizes to that member's exact casing, and
+ * everything else yields `fallback`.
+ *
+ * This is emitted ONLY on the already-invalid branch of the coercion ternary, so
+ * a correctly-cased value never reaches it — the exact `===` fast path (and the
+ * shape validators / deep guards built on it) is unchanged, so the hot path pays
+ * nothing. Only a mis-cased value, which today coerces straight to the default,
+ * now takes a single `toLowerCase()` and an O(1) map lookup instead.
+ *
+ * Returns `null` when no member is a string (nothing to fold), so the caller
+ * keeps its plain fallback and emits no extra code.
+ */
+export declare const generateEnumCaseInsensitiveCoercion: (accessor: string, enumValues: readonly unknown[], fallback: string) => string | null;

package/dist/generators/generate-enum-check.js

@@ -20,3 +20,35 @@ export const generateEnumCheck = (accessor, enumValues) => {
     const serializedEnum = JSON.stringify(enumValues);
     return `${serializedEnum}.includes(${accessor} as never)`;
 };
+/**
+ * Builds a case-insensitive coercion expression for a string `enum`/`const`
+ * value whose exact-match check has already failed. Only the *string* members
+ * participate (a number/boolean/null member has no case to fold): a value that
+ * matches one case-insensitively normalizes to that member's exact casing, and
+ * everything else yields `fallback`.
+ *
+ * This is emitted ONLY on the already-invalid branch of the coercion ternary, so
+ * a correctly-cased value never reaches it — the exact `===` fast path (and the
+ * shape validators / deep guards built on it) is unchanged, so the hot path pays
+ * nothing. Only a mis-cased value, which today coerces straight to the default,
+ * now takes a single `toLowerCase()` and an O(1) map lookup instead.
+ *
+ * Returns `null` when no member is a string (nothing to fold), so the caller
+ * keeps its plain fallback and emits no extra code.
+ */
+export const generateEnumCaseInsensitiveCoercion = (accessor, enumValues, fallback) => {
+    const byLower = {};
+    for (const value of enumValues) {
+        if (typeof value !== 'string')
+            continue;
+        const lower = value.toLowerCase();
+        // First writer wins, so declaration order breaks ties between members that
+        // fold to the same key (e.g. `"on"` and `"ON"`).
+        if (!(lower in byLower))
+            byLower[lower] = value;
+    }
+    if (Object.keys(byLower).length === 0)
+        return null;
+    const map = JSON.stringify(byLower);
+    return `(typeof ${accessor} === "string" ? ((${map} as Record<string, string>)[(${accessor} as string).toLowerCase()] ?? ${fallback}) : ${fallback})`;
+};

package/dist/generators/generate-files.d.ts

@@ -71,6 +71,20 @@ type GenerateFileOptions = {
      * stripping.
      */
     readonly importExt?: ImportExtension;
+    /**
+     * True when this file is the root document rather than a `$ref`-reached
+     * definition. Forwarded to the parser generator so the JSON Schema
+     * meta-schema special case (type name `Schema`) never applies to a
+     * user-named root.
+     */
+    readonly isRoot?: boolean;
+    /**
+     * When true, a mis-cased string that matches a declared `enum`/`const` member
+     * case-insensitively is normalized to that member's exact casing (coerce mode
+     * only). The normalization is emitted on the coercion failure branch, so
+     * already-valid input keeps the exact-match fast path.
+     */
+    readonly caseInsensitive?: boolean;
 };
 /** Result of generating a single parser file. */
 export type GeneratedFileContent = {

package/dist/generators/generate-files.js

@@ -62,10 +62,12 @@ export const generateFile = (schema, typeName, options) => {
         useRefImports: true,
         typeSuffix,
         reservedNames,
+        ...(options?.isRoot !== undefined ? { isRoot: options.isRoot } : {}),
         ...(rootSchema !== undefined ? { rootSchema } : {}),
         ...(options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}),
         ...(options?.strict !== undefined ? { strict: options.strict } : {}),
         ...(options?.stripUnknown !== undefined ? { stripUnknown: options.stripUnknown } : {}),
+        ...(options?.caseInsensitive !== undefined ? { caseInsensitive: options.caseInsensitive } : {}),
     });
     const shapeValidator = generateShapeValidator(schema, typeName, true, typeSuffix, true, stripUnknown, reservedNames);
     const combinedFunctions = `${shapeValidator}\n\n${parserFunction}`;

package/dist/generators/generate-parser-function.d.ts

@@ -50,6 +50,23 @@ type GenerateParserOptions = {
      * validate against the wrong schema.
      */
     readonly reservedNames?: ReadonlySet<string>;
+    /**
+     * True when this schema is the root document (not a `$ref`-reached definition).
+     * The root type name is user-derived (schema `title`, filename, or `--root-type`),
+     * so the JSON Schema meta-schema special case — keyed on the literal name
+     * `Schema` — must not apply to it, or a common `schema.json` root would silently
+     * generate a validation-free pass-through parser.
+     */
+    readonly isRoot?: boolean;
+    /**
+     * When true, a mis-cased string that matches a declared `enum`/`const` member
+     * case-insensitively is normalized to that member's exact casing (e.g. `hElLo`
+     * → `hello`) instead of coercing to the default. Coerce mode only — strict
+     * parsers still reject a casing mismatch. The normalization lives on the
+     * failure branch of the coercion ternary, so a correctly-cased value keeps the
+     * exact `===` fast path and the hot path is unaffected.
+     */
+    readonly caseInsensitive?: boolean;
 };
 /**
  * Generates a safe parser as an arrow function that never throws.

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

@@ -8,6 +8,7 @@ import { unknownKeyCheck } from '@amritk/helpers/unknown-key-check';
 import { findDiscriminator } from '../helpers/find-discriminator.js';
 import { getDefaultValue } from '../helpers/get-default-value.js';
 import { getDiscriminatorValue } from '../helpers/get-discriminator-value.js';
+import { generateEnumCaseInsensitiveCoercion } from './generate-enum-check.js';
 import { generateObjectStrictAssertion, generateScalarStrictAssertion } from './generate-strict-assertion.js';
 import { canEnforceUnion, generatePropertyTypeCheck, generateUnionCheck, getUnionBranches, isInlineObjectArrayProperty, isInlineObjectProperty, shapeValidatorName, } from './generate-type-checks.js';
 import { generateValidationExpression, isCoercibleItemSchema } from './generate-validation-expression.js';
@@ -147,7 +148,7 @@ const shouldUseRecordRefImport = (propSchema, useRefImports) => {
 /**
  * Generates the value expression for a property based on its schema and options.
  */
-const generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffix) => {
+const generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffix, caseInsensitive = false) => {
     // Handle direct $ref properties
     if (shouldUseRefImport(propSchema, useRefImports)) {
         const ref = propSchema.$ref;
@@ -173,20 +174,20 @@ const generatePropertyValue = (key, propSchema, isRequired, useRefImports, suffi
     }
     // Generate standard validation expression
     const defaultValue = getDefaultValue(propSchema);
-    const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired);
+    const valueExpression = generateValidationExpression(key, propSchema, defaultValue, isRequired, undefined, undefined, undefined, undefined, caseInsensitive);
     return isRequired ? valueExpression : generateOptionalInlineProperty(key, valueExpression);
 };
 /**
  * Generates property entries for all properties in the schema.
  */
-const generatePropertyEntries = (schema, useRefImports, suffix) => {
+const generatePropertyEntries = (schema, useRefImports, suffix, caseInsensitive = false) => {
     if (!hasProperties(schema)) {
         return [];
     }
     const entries = [];
     for (const [key, propSchema] of Object.entries(schema.properties)) {
         const isRequired = isPropertyRequired(key, schema);
-        const value = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix);
+        const value = generatePropertyValue(key, propSchema, isRequired, useRefImports, suffix, caseInsensitive);
         // Determine if the property uses spread syntax (making it optional in the object literal)
         const isOptional = value.startsWith('...');
         entries.push({ key, value, isOptional });
@@ -419,7 +420,11 @@ const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
         if (hasEnum(schema) && schema.enum.length > 0) {
             const values = JSON.stringify(schema.enum);
             const fallback = JSON.stringify(schema.enum[0]);
-            return `export const ${functionName} = (input: unknown): ${typeName} => ${values}.includes(input as never) ? input as ${typeName} : ${fallback} as ${typeName};`;
+            // Case-insensitive normalization sits on the non-member branch only, so an
+            // exact member still returns via the `includes` fast path untouched.
+            const ci = unionCtx?.caseInsensitive ? generateEnumCaseInsensitiveCoercion('input', schema.enum, fallback) : null;
+            const coerced = ci ? `(${ci})` : fallback;
+            return `export const ${functionName} = (input: unknown): ${typeName} => ${values}.includes(input as never) ? input as ${typeName} : ${coerced} as ${typeName};`;
         }
         // A top-level union must validate membership: an unmatched value is not of
         // the declared union type, so coerce it to a member-shaped default. Reuse the
@@ -477,7 +482,7 @@ const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
             const preamble = [
                 `type ${itemName} = ${typeName}[number];`,
                 generateShapeValidator(items, itemName, useRefImports, suffix, false, stripUnknown, reserved),
-                generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved),
+                generateObjectParser(items, itemName, useRefImports, suffix, unionCtx?.logWarnings ?? false, strict, false, stripUnknown, unionCtx?.rootSchema, reserved, unionCtx?.caseInsensitive ?? false),
             ].join('\n\n');
             return `${preamble}\n\n${delegated(generateParserName(itemName))}`;
         }
@@ -511,7 +516,7 @@ const generateNonObjectParser = (typeName, schema, strict, unionCtx) => {
             // Coerce each element when the item schema is a single scalar type or an enum.
             if (hasItems(schema) && !Array.isArray(schema.items) && isCoercibleItemSchema(schema.items)) {
                 const item = schema.items;
-                const itemExpr = generateValidationExpression('', item, getDefaultValue(item), true, undefined, undefined, '_it', true);
+                const itemExpr = generateValidationExpression('', item, getDefaultValue(item), true, undefined, undefined, '_it', true, unionCtx?.caseInsensitive);
                 return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? (input as unknown[]).map((_it) => ${itemExpr}) as ${typeName} : [] as ${typeName};`;
             }
             return `export const ${functionName} = (input: unknown): ${typeName} => Array.isArray(input) ? [...input] as ${typeName} : [] as ${typeName};`;
@@ -664,7 +669,7 @@ const shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
  * - Fast path that returns input directly when all properties are already valid
  * - Slow path with optimized expressions
  */
-const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES) => {
+const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, exported = true, stripUnknown = false, rootSchema, reservedNames = NO_RESERVED_NAMES, caseInsensitive = false) => {
     const functionName = generateParserName(typeName);
     const exportPrefix = exported ? 'export ' : '';
     if (!hasProperties(schema)) {
@@ -690,7 +695,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         const propSchema = schemaProps[key];
         preamble.push(`type ${subName} = ${typeName}[${JSON.stringify(key)}];`);
         preamble.push(generateShapeValidator(propSchema, subName, useRefImports, suffix, false, stripUnknown, reservedNames));
-        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames));
+        preamble.push(generateObjectParser(propSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive));
     }
     for (const [key, subName] of subItemNames) {
         const propSchema = schemaProps[key];
@@ -701,7 +706,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
         // Hand-rolled loop instead of Array.prototype.every on the guard path — the
         // callback protocol costs a few percent on element-heavy hot paths.
         preamble.push(`const _every${subName} = (arr: readonly unknown[]): boolean => {\n  for (let i = 0; i < arr.length; i++) if (!${shapeValidatorName(subName)}(arr[i])) return false;\n  return true;\n};`);
-        preamble.push(generateObjectParser(itemSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames));
+        preamble.push(generateObjectParser(itemSchema, subName, useRefImports, suffix, logWarnings, strict, false, stripUnknown, rootSchema, reservedNames, caseInsensitive));
     }
     // additionalProperties: false — the per-key "is this undeclared" test inlines
     // `!==` comparisons for a short key list and hoists a Set only for a long one
@@ -979,7 +984,7 @@ const generateObjectParser = (schema, typeName, useRefImports, suffix, logWarnin
                 // For optional properties we know the value is not undefined because
                 // we're inside the `...(accessor !== undefined && { ... })` check.
                 const knownNotUndefined = !isRequired;
-                valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, undefined, undefined, shouldCache ? varName : undefined, knownNotUndefined);
+                valueExpr = generateValidationExpression(key, propSchema, defaultValue, true, undefined, undefined, shouldCache ? varName : undefined, knownNotUndefined, caseInsensitive);
             }
             if (isRequired) {
                 objectLines.push(`    ${safeKey(key)}: ${valueExpr},`);
@@ -1193,9 +1198,9 @@ ${loopLines.join('\n')}
  * Generates a parser for schemas that have both properties AND patternProperties.
  * Parses the known properties first, then iterates remaining keys to match patterns.
  */
-const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false) => {
+const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown = false, caseInsensitive = false) => {
     const functionName = generateParserName(typeName);
-    const entries = generatePropertyEntries(schema, useRefImports, suffix);
+    const entries = generatePropertyEntries(schema, useRefImports, suffix, caseInsensitive);
     // Build the known property lines for the initial object
     const propertyLines = entries.map((entry) => {
         if (entry.isOptional) {
@@ -1205,7 +1210,7 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
     });
     // Find the first pattern with a $ref for parser delegation
     if (!isSchemaObject(schema) || !('patternProperties' in schema)) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown);
+        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
     }
     const patternProps = schema.patternProperties;
     const patterns = Object.entries(patternProps);
@@ -1219,7 +1224,7 @@ const generateCombinedObjectParser = (schema, typeName, useRefImports, suffix, l
         return generateStrictCombinedParser(schema, typeName, functionName, propertyLines, patterns, useRefImports, suffix, strict);
     }
     if (!refPattern || !useRefImports) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown);
+        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
     }
     const [pattern, patternSchema] = refPattern;
     const ref = patternSchema.$ref;
@@ -1398,7 +1403,7 @@ ${notObjectBranch}
  * This always generates parser calls regardless of useRefImports setting,
  * because conditional logic requires delegating to the appropriate parser.
  */
-const generateConditionalParser = (schema, typeName, suffix, stripUnknown = false) => {
+const generateConditionalParser = (schema, typeName, suffix, stripUnknown = false, caseInsensitive = false) => {
     const functionName = generateParserName(typeName);
     // Extract the condition and branches
     const ifSchema = schema.if;
@@ -1413,7 +1418,7 @@ const generateConditionalParser = (schema, typeName, suffix, stripUnknown = fals
         // regular object parser from the merged property set.
         const mergedSchema = getConditionalObjectSchema(schema);
         if (mergedSchema) {
-            return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown);
+            return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
         }
         return generateEmptyObjectParser(typeName);
     }
@@ -1427,7 +1432,7 @@ const generateConditionalParser = (schema, typeName, suffix, stripUnknown = fals
         // Condition is not a $ref check — flatten into an object parser
         const mergedSchema = getConditionalObjectSchema(schema);
         if (mergedSchema) {
-            return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown);
+            return generateObjectParser(mergedSchema, typeName, false, suffix, false, false, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
         }
         return generateEmptyObjectParser(typeName);
     }
@@ -1523,10 +1528,15 @@ const selectParserStrategy = (schema, typeName, options) => {
     const logWarnings = options?.logWarnings ?? false;
     const strict = options?.strict ?? false;
     const stripUnknown = options?.stripUnknown ?? false;
+    const caseInsensitive = options?.caseInsensitive ?? false;
     const suffix = options?.typeSuffix ?? '';
     // Special case for the self-referential JSON Schema meta-schema type (e.g.
-    // `Schema` / `SchemaObject`) - it can be any JSON Schema.
-    if (typeName === `Schema${suffix}`) {
+    // `Schema` / `SchemaObject`) - it can be any JSON Schema. This is an OpenAPI
+    // heuristic for a `$defs`/`components.schemas` entry named `schema`; it must
+    // never fire for the root document, whose name is user-derived (a `schema.json`
+    // file naturally yields the root type `Schema`) and would otherwise collapse
+    // to a validation-free pass-through parser.
+    if (!options?.isRoot && typeName === `Schema${suffix}`) {
         return generateSchemaObjectParser(typeName);
     }
     const isObjectLikeSchema = isObjectSchema(schema) ||
@@ -1537,6 +1547,7 @@ const selectParserStrategy = (schema, typeName, options) => {
             useRefImports,
             suffix,
             stripUnknown,
+            caseInsensitive,
             logWarnings,
             ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
             ...(options?.reservedNames !== undefined ? { reservedNames: options.reservedNames } : {}),
@@ -1546,24 +1557,24 @@ const selectParserStrategy = (schema, typeName, options) => {
     // This generates a parser that handles known properties and also iterates
     // pattern-matched keys (e.g. responses with "default" + "200", "4XX").
     if (hasProperties(schema) && isSchemaObject(schema) && 'patternProperties' in schema) {
-        return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown);
+        return generateCombinedObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, stripUnknown, caseInsensitive);
     }
     // Handle schemas that have explicit properties — generate a full object parser.
     // This intentionally runs before if/then checks so that schemas with both
     // properties AND conditional keywords use all declared properties rather than
     // only the if/then fragment.
     if (hasProperties(schema)) {
-        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames);
+        return generateObjectParser(schema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, options?.rootSchema, options?.reservedNames, caseInsensitive);
     }
     // Handle conditional schemas (if/then/else) for schemas without explicit properties.
     if (isSchemaObject(schema) && 'if' in schema && 'then' in schema && 'else' in schema) {
-        return generateConditionalParser(schema, typeName, suffix, stripUnknown);
+        return generateConditionalParser(schema, typeName, suffix, stripUnknown, caseInsensitive);
     }
     // Handle conditional schemas that only define if/then object fragments.
     // We flatten the fragments into a regular object parser.
     const conditionalObjectSchema = getConditionalObjectSchema(schema);
     if (conditionalObjectSchema) {
-        return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown);
+        return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, suffix, logWarnings, strict, true, stripUnknown, undefined, NO_RESERVED_NAMES, caseInsensitive);
     }
     // Handle non-object schemas with type-appropriate validation (no properties, no conditionals)
     if (!isObjectLikeSchema) {
@@ -1571,6 +1582,7 @@ const selectParserStrategy = (schema, typeName, options) => {
             useRefImports,
             suffix,
             stripUnknown,
+            caseInsensitive,
             logWarnings,
             ...(options?.rootSchema !== undefined ? { rootSchema: options.rootSchema } : {}),
             ...(options?.reservedNames !== undefined ? { reservedNames: options.reservedNames } : {}),

package/dist/generators/generate-validation-expression.d.ts

@@ -18,4 +18,4 @@ export declare const isCoercibleItemSchema: (itemSchema: JSONSchema) => boolean;
  * Returns the value if valid, coerces to the correct type if invalid, or uses default if required and missing.
  * Supports type checking, pattern validation, enum validation, union types, and $ref resolution.
  */
-export declare const generateValidationExpression: (key: string, schema: JSONSchema, defaultValue: string, isRequired: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, accessorOverride?: string, knownNotUndefined?: boolean) => string;
+export declare const generateValidationExpression: (key: string, schema: JSONSchema, defaultValue: string, isRequired: boolean, rootSchema?: Record<string, unknown>, visitedRefs?: Set<string>, accessorOverride?: string, knownNotUndefined?: boolean, caseInsensitive?: boolean) => string;

package/dist/generators/generate-validation-expression.js

@@ -7,7 +7,7 @@ import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExcl
 import { findDiscriminator } from '../helpers/find-discriminator.js';
 import { getDefaultValue } from '../helpers/get-default-value.js';
 import { generateDiscriminatedUnionValidation } from './generate-discriminated-union-validation.js';
-import { generateEnumCheck } from './generate-enum-check.js';
+import { generateEnumCaseInsensitiveCoercion, generateEnumCheck } from './generate-enum-check.js';
 import { generateNonDiscriminatedUnionValidation } from './generate-non-discriminated-union-validation.js';
 import { generateSchemaChecks } from './generate-schema-checks.js';
 /**
@@ -128,7 +128,7 @@ const getTypeCoercion = (accessor, schema, defaultValue) => {
  * Returns the value if valid, coerces to the correct type if invalid, or uses default if required and missing.
  * Supports type checking, pattern validation, enum validation, union types, and $ref resolution.
  */
-export const generateValidationExpression = (key, schema, defaultValue, isRequired, rootSchema, visitedRefs, accessorOverride, knownNotUndefined) => {
+export const generateValidationExpression = (key, schema, defaultValue, isRequired, rootSchema, visitedRefs, accessorOverride, knownNotUndefined, caseInsensitive) => {
     const accessor = accessorOverride ?? safeAccessor('input?', key);
     const checks = [];
     if (!isSchemaObject(schema)) {
@@ -170,7 +170,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
         if (resolvedSchema) {
             const visited = new Set(visitedRefs);
             visited.add(ref);
-            return generateValidationExpression(key, resolvedSchema, defaultValue, isRequired, rootSchema, visited);
+            return generateValidationExpression(key, resolvedSchema, defaultValue, isRequired, rootSchema, visited, undefined, undefined, caseInsensitive);
         }
     }
     // Handle union types (oneOf, anyOf)
@@ -250,7 +250,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
         !Array.isArray(schema.items) &&
         isCoercibleItemSchema(schema.items)) {
         const itemSchema = schema.items;
-        const itemExpr = generateValidationExpression('', itemSchema, getDefaultValue(itemSchema), true, rootSchema, visitedRefs, '_it', true);
+        const itemExpr = generateValidationExpression('', itemSchema, getDefaultValue(itemSchema), true, rootSchema, visitedRefs, '_it', true, caseInsensitive);
         const mapped = `(Array.isArray(${accessor}) ? (${accessor} as unknown[]).map((_it) => ${itemExpr}) : ${defaultValue})`;
         return isRequired ? mapped : `(${accessor} !== undefined ? ${mapped} : undefined)`;
     }
@@ -361,6 +361,14 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
     // enum. Fall back to the default (the first enum value) so the result is always
     // a valid member of the declared literal-union type.
     const typeCoercion = hasEnum(schema) ? null : getTypeCoercion(accessor, schema, defaultValue);
+    // Case-insensitive enum normalization is spliced into the *failure* branch of
+    // the ternary only, so an already-valid (exactly-cased) member takes the
+    // `${accessor}` fast branch untouched. A mis-cased string folds to the exact
+    // member; anything else falls through to the branch's normal fallback. `null`
+    // when the flag is off or no member is a string, so the plain fallback stands.
+    const enumFallback = (fallback) => (caseInsensitive && hasEnum(schema) && schema.enum.length > 0
+        ? generateEnumCaseInsensitiveCoercion(accessor, schema.enum, fallback)
+        : null) ?? fallback;
     if (isRequired) {
         // For required fields: valid ? use_value : (exists ? coerce : default)
         if (typeCoercion) {
@@ -371,7 +379,7 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             }
             return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : ${defaultValue})`;
         }
-        return `${combinedCheck} ? ${accessor} : ${defaultValue}`;
+        return `${combinedCheck} ? ${accessor} : ${enumFallback(defaultValue)}`;
     }
     else {
         // For optional fields: valid ? use_value : (exists ? coerce : undefined)
@@ -382,6 +390,6 @@ export const generateValidationExpression = (key, schema, defaultValue, isRequir
             }
             return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : undefined)`;
         }
-        return `${combinedCheck} ? ${accessor} : undefined`;
+        return `${combinedCheck} ? ${accessor} : ${enumFallback('undefined')}`;
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.14.0",
+  "version": "0.16.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.11.0",
+    "@amritk/helpers": "0.12.0",
     "@amritk/generate-markdown": "0.4.1"
   },
   "devDependencies": {