@amritk/generate-parsers 0.6.3 → 0.7.1

package/dist/generators/generate-schema-checks.d.ts

@@ -3,3 +3,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * Generates validation checks for a single schema (used in union validation).
  */
 export declare const generateSchemaChecks: (accessor: string, schema: JSONSchema) => string[];
+//# sourceMappingURL=generate-schema-checks.d.ts.map

package/dist/generators/generate-schema-checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-schema-checks.d.ts","sourceRoot":"","sources":["../../src/generators/generate-schema-checks.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAIjE;;GAEG;AACH,eAAO,MAAM,oBAAoB,aAAc,MAAM,UAAU,UAAU,KAAG,MAAM,EAkGjF,CAAA"}

package/dist/generators/generate-schema-checks.js

@@ -0,0 +1,99 @@
+import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { hasAdditionalProperties, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, } from '@amritk/helpers/schema-guards';
+import { generateEnumCheck } from './generate-enum-check.js';
+/**
+ * Generates validation checks for a single schema (used in union validation).
+ */
+export const generateSchemaChecks = (accessor, schema) => {
+    const checks = [];
+    // x-mjst instanceOf nodes validate purely by instance check (no native type).
+    const instanceOf = getMjstInstanceOf(schema);
+    if (instanceOf) {
+        return [`${accessor} instanceof ${instanceOf}`];
+    }
+    // x-mjst primitive nodes (e.g. bigint) validate purely by typeof check.
+    const primitive = getMjstPrimitive(schema);
+    if (primitive) {
+        return [`typeof ${accessor} === "${primitive}"`];
+    }
+    if (!hasType(schema)) {
+        return checks;
+    }
+    switch (schema.type) {
+        case 'string': {
+            checks.push(`typeof ${accessor} === "string"`);
+            if (hasPattern(schema)) {
+                checks.push(`/${schema.pattern.replace(/\//g, '\\/')}/.test(${accessor})`);
+            }
+            if (hasMinLength(schema)) {
+                checks.push(`${accessor}.length >= ${schema.minLength}`);
+            }
+            if (hasMaxLength(schema)) {
+                checks.push(`${accessor}.length <= ${schema.maxLength}`);
+            }
+            break;
+        }
+        case 'number':
+        case 'integer':
+            checks.push(`typeof ${accessor} === "number"`);
+            if (hasMinimum(schema)) {
+                checks.push(`${accessor} >= ${schema.minimum}`);
+            }
+            if (hasMaximum(schema)) {
+                checks.push(`${accessor} <= ${schema.maximum}`);
+            }
+            if (hasExclusiveMinimum(schema)) {
+                checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+            }
+            if (hasExclusiveMaximum(schema)) {
+                checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+            }
+            if (hasMultipleOf(schema)) {
+                checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+            }
+            break;
+        case 'boolean':
+            checks.push(`typeof ${accessor} === "boolean"`);
+            break;
+        case 'array':
+            checks.push(`Array.isArray(${accessor})`);
+            if (hasMinItems(schema)) {
+                checks.push(`${accessor}.length >= ${schema.minItems}`);
+            }
+            if (hasMaxItems(schema)) {
+                checks.push(`${accessor}.length <= ${schema.maxItems}`);
+            }
+            if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+                checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+            }
+            break;
+        case 'object': {
+            checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
+            // Check required properties exist
+            if (hasRequired(schema) && schema.required.length > 0) {
+                for (const requiredKey of schema.required) {
+                    checks.push(`"${requiredKey}" in ${accessor}`);
+                }
+            }
+            // Check minProperties
+            if (hasMinProperties(schema)) {
+                checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
+            }
+            // Check maxProperties
+            if (hasMaxProperties(schema)) {
+                checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
+            }
+            // Check additionalProperties
+            if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
+                const allowedKeys = Object.keys(schema.properties);
+                const allowedKeysStr = JSON.stringify(allowedKeys);
+                checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
+            }
+            break;
+        }
+    }
+    if (hasEnum(schema) && schema.enum.length > 0) {
+        checks.push(generateEnumCheck(accessor, schema.enum));
+    }
+    return checks;
+};

package/dist/generators/generate-strict-assertion.d.ts

@@ -16,3 +16,4 @@ export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeNam
  * Returns null when the schema has no type information to assert on.
  */
 export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string) => string | null;
+//# sourceMappingURL=generate-strict-assertion.d.ts.map

package/dist/generators/generate-strict-assertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-strict-assertion.d.ts","sourceRoot":"","sources":["../../src/generators/generate-strict-assertion.ts"],"names":[],"mappings":"AAkBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAsLjE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,WAAY,UAAU,YAAY,MAAM,KAAG,MAAM,EAe1F,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,6BAA6B,WAAY,UAAU,YAAY,MAAM,KAAG,MAAM,GAAG,IAgB7F,CAAA"}

package/dist/generators/generate-strict-assertion.js

@@ -0,0 +1,179 @@
+import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { safeAccessor } from '@amritk/helpers/safe-accessor';
+import { hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaximum, hasMaxLength, hasMinimum, hasMinLength, hasMultipleOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, isSchemaObject, } from '@amritk/helpers/schema-guards';
+/**
+ * Returns the inline condition that is true when `accessor` is the wrong type
+ * for the given JSON Schema primitive type.
+ */
+const wrongTypeCondition = (accessor, type) => {
+    switch (type) {
+        case 'string':
+            return `typeof ${accessor} !== "string"`;
+        case 'number':
+        case 'integer':
+            return `typeof ${accessor} !== "number"`;
+        case 'boolean':
+            return `typeof ${accessor} !== "boolean"`;
+        case 'array':
+            return `!Array.isArray(${accessor})`;
+        case 'object':
+            return `!isObject(${accessor})`;
+        default:
+            return null;
+    }
+};
+/**
+ * Maps a JSON Schema type to the label used in error messages.
+ * `integer` collapses to `number` since both are validated via `typeof === "number"`.
+ */
+const typeLabel = (type) => (type === 'integer' ? 'number' : type);
+/**
+ * Escapes special regex characters in a pattern string for use in a regex literal.
+ */
+const escapeRegexPattern = (pattern) => {
+    return pattern.replace(/\\/g, '\\\\').replace(/\//g, '\\/');
+};
+/**
+ * Generates strict-mode constraint checks for a typed property
+ * (pattern, length, min/max, multipleOf).
+ */
+const generateConstraintChecks = (acc, propSchema, typeName, key) => {
+    if (!isSchemaObject(propSchema) || !hasType(propSchema))
+        return [];
+    const t = propSchema.type;
+    const lines = [];
+    if (t === 'string') {
+        if (hasPattern(propSchema)) {
+            const pattern = escapeRegexPattern(propSchema.pattern);
+            lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) throw new Error('[${typeName}] field "${key}" must match pattern ${propSchema.pattern}');`);
+        }
+        if (hasMinLength(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) throw new Error('[${typeName}] field "${key}" must have at least ${propSchema.minLength} characters');`);
+        }
+        if (hasMaxLength(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) throw new Error('[${typeName}] field "${key}" must have at most ${propSchema.maxLength} characters');`);
+        }
+    }
+    if (t === 'number' || t === 'integer') {
+        if (hasMinimum(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) throw new Error('[${typeName}] field "${key}" must be >= ${propSchema.minimum}');`);
+        }
+        if (hasMaximum(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) throw new Error('[${typeName}] field "${key}" must be <= ${propSchema.maximum}');`);
+        }
+        if (hasExclusiveMinimum(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) throw new Error('[${typeName}] field "${key}" must be > ${propSchema.exclusiveMinimum}');`);
+        }
+        if (hasExclusiveMaximum(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) throw new Error('[${typeName}] field "${key}" must be < ${propSchema.exclusiveMaximum}');`);
+        }
+        if (hasMultipleOf(propSchema)) {
+            lines.push(`  if (typeof ${acc} === "number" && ${acc} % ${propSchema.multipleOf} !== 0) throw new Error('[${typeName}] field "${key}" must be a multiple of ${propSchema.multipleOf}');`);
+        }
+    }
+    return lines;
+};
+/**
+ * Generates strict-mode lines for a single property of an object schema.
+ * Properties with a `$ref` are skipped here — the nested parser handles its own
+ * strict check when called from the parent's slow path.
+ */
+const generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
+    const acc = safeAccessor('input', key);
+    const lines = [];
+    if (isRequired) {
+        lines.push(`  if (!(${JSON.stringify(key)} in input)) throw new Error('[${typeName}] missing required property "${key}"');`);
+    }
+    if (!isSchemaObject(propSchema))
+        return lines;
+    if (hasRef(propSchema))
+        return lines;
+    const instanceOf = getMjstInstanceOf(propSchema);
+    if (instanceOf) {
+        if (isRequired) {
+            lines.push(`  if (!(${acc} instanceof ${instanceOf})) throw new Error('[${typeName}] field "${key}" must be ${instanceOf}');`);
+        }
+        else {
+            lines.push(`  if (${acc} !== undefined && !(${acc} instanceof ${instanceOf})) throw new Error('[${typeName}] field "${key}" must be ${instanceOf}');`);
+        }
+        return lines;
+    }
+    const primitive = getMjstPrimitive(propSchema);
+    if (primitive) {
+        if (isRequired) {
+            lines.push(`  if (typeof ${acc} !== "${primitive}") throw new Error('[${typeName}] field "${key}" must be ${primitive}');`);
+        }
+        else {
+            lines.push(`  if (${acc} !== undefined && typeof ${acc} !== "${primitive}") throw new Error('[${typeName}] field "${key}" must be ${primitive}');`);
+        }
+        return lines;
+    }
+    if (hasEnum(propSchema)) {
+        const allowed = JSON.stringify(propSchema.enum);
+        const label = propSchema.enum.map((v) => JSON.stringify(v)).join(', ');
+        if (isRequired) {
+            lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+        }
+        else {
+            lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+        }
+        return lines;
+    }
+    if (hasType(propSchema)) {
+        const t = propSchema.type;
+        const wrongType = wrongTypeCondition(acc, t);
+        if (wrongType) {
+            if (isRequired) {
+                lines.push(`  if (${wrongType}) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+            }
+            else {
+                lines.push(`  if (${acc} !== undefined && (${wrongType})) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+            }
+        }
+        lines.push(...generateConstraintChecks(acc, propSchema, typeName, key));
+    }
+    return lines;
+};
+/**
+ * Generates strict-mode assertions for the body of an object parser.
+ * Throws on:
+ *   - non-object input
+ *   - missing required property
+ *   - property of the wrong primitive type
+ *   - enum / pattern / length / min / max / multipleOf violations
+ *
+ * Properties with a `$ref` are validated by the nested parser's own strict
+ * check when that parser is invoked downstream.
+ */
+export const generateObjectStrictAssertion = (schema, typeName) => {
+    const lines = [];
+    lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
+    if (!hasProperties(schema) || !isSchemaObject(schema))
+        return lines;
+    const required = new Set(hasRequired(schema) ? schema.required : []);
+    for (const [key, propSchema] of Object.entries(schema.properties)) {
+        lines.push(...generatePropertyAssertion(key, propSchema, required.has(key), typeName));
+    }
+    return lines;
+};
+/**
+ * Generates a single strict-mode assertion line for a non-object scalar parser.
+ * Returns null when the schema has no type information to assert on.
+ */
+export const generateScalarStrictAssertion = (schema, typeName) => {
+    const instanceOf = getMjstInstanceOf(schema);
+    if (instanceOf) {
+        return `  if (!(input instanceof ${instanceOf})) throw new Error(\`[${typeName}] expected ${instanceOf}, got \${input === null ? "null" : typeof input}\`);`;
+    }
+    const primitive = getMjstPrimitive(schema);
+    if (primitive) {
+        return `  if (typeof input !== "${primitive}") throw new Error(\`[${typeName}] expected ${primitive}, got \${input === null ? "null" : typeof input}\`);`;
+    }
+    if (!isSchemaObject(schema) || !hasType(schema))
+        return null;
+    const t = schema.type;
+    const wrongType = wrongTypeCondition('input', t);
+    if (!wrongType)
+        return null;
+    return `  if (${wrongType}) throw new Error(\`[${typeName}] expected ${typeLabel(t)}, got \${input === null ? "null" : typeof input}\`);`;
+};

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

@@ -5,3 +5,4 @@ import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
  * 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;
+//# sourceMappingURL=generate-validation-expression.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate-validation-expression.d.ts","sourceRoot":"","sources":["../../src/generators/generate-validation-expression.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AAgDjE;;;;GAIG;AACH,eAAO,MAAM,4BAA4B,QAClC,MAAM,UACH,UAAU,gBACJ,MAAM,cACR,OAAO,eACN,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,gBACtB,GAAG,CAAC,MAAM,CAAC,qBACN,MAAM,sBACL,OAAO,KAC1B,MA0OF,CAAA"}

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

@@ -0,0 +1,267 @@
+import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension';
+import { resolveRef } from '@amritk/helpers/resolve-ref';
+import { safeAccessor } from '@amritk/helpers/safe-accessor';
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasOneOf, hasPattern, hasProperties, hasRef, hasRequired, hasType, hasUniqueItems, isSchemaObject, } from '@amritk/helpers/schema-guards';
+import { findDiscriminator } from '../helpers/find-discriminator.js';
+import { generateDiscriminatedUnionValidation } from './generate-discriminated-union-validation.js';
+import { generateEnumCheck } from './generate-enum-check.js';
+import { generateNonDiscriminatedUnionValidation } from './generate-non-discriminated-union-validation.js';
+import { generateSchemaChecks } from './generate-schema-checks.js';
+/**
+ * Coercion expression for an `x-mjst` instanceOf value, when one is known.
+ * `Date` can be reconstructed from the common JSON encodings (ISO string or
+ * epoch number); other classes have no safe generic coercion, so we return null
+ * and the caller falls back to the default.
+ */
+const getInstanceCoercion = (accessor, instanceOf) => {
+    if (instanceOf === 'Date')
+        return `new Date(${accessor} as string | number | Date)`;
+    return null;
+};
+/**
+ * Generates a type coercion expression for converting a value to the expected type.
+ */
+const getTypeCoercion = (accessor, schema, defaultValue) => {
+    if (!hasType(schema)) {
+        return null;
+    }
+    switch (schema.type) {
+        case 'string':
+            return `String(${accessor})`;
+        case 'number':
+        case 'integer': {
+            // Number() of a non-numeric string produces NaN, which silently poisons
+            // arithmetic. Guard with Number.isFinite and fall back to the default.
+            const n = `Number(${accessor})`;
+            return `(Number.isFinite(${n}) ? ${n} : ${defaultValue})`;
+        }
+        case 'boolean':
+            return `Boolean(${accessor})`;
+        case 'array':
+            return `[]`;
+        case 'object':
+            return `typeof ${accessor} === "object" && ${accessor} !== null ? ${accessor} : {}`;
+        default:
+            return null;
+    }
+};
+/**
+ * Generates a validation expression that checks if a value matches the expected type.
+ * 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) => {
+    const accessor = accessorOverride ?? safeAccessor('input?', key);
+    const checks = [];
+    if (!isSchemaObject(schema)) {
+        return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+    }
+    // Handle x-mjst instanceOf (e.g. Date): the value must be an instance of the
+    // named class. Invalid values are coerced when a coercer is known, otherwise
+    // they fall back to the default (required) or undefined (optional).
+    const instanceOf = getMjstInstanceOf(schema);
+    if (instanceOf) {
+        const valid = `${accessor} instanceof ${instanceOf}`;
+        const coercion = getInstanceCoercion(accessor, instanceOf);
+        if (isRequired) {
+            return coercion
+                ? `${valid} ? ${accessor} : (${accessor} !== undefined ? ${coercion} : ${defaultValue})`
+                : `${valid} ? ${accessor} : ${defaultValue}`;
+        }
+        return coercion
+            ? `${valid} ? ${accessor} : (${accessor} !== undefined ? ${coercion} : undefined)`
+            : `${valid} ? ${accessor} : undefined`;
+    }
+    // Handle x-mjst primitive (e.g. bigint): validate with typeof. We do not
+    // coerce — BigInt() throws on invalid input, which a pure coercion expression
+    // cannot guard — so invalid values fall back to the default (required) or
+    // undefined (optional).
+    const primitive = getMjstPrimitive(schema);
+    if (primitive) {
+        const valid = `typeof ${accessor} === "${primitive}"`;
+        return isRequired ? `${valid} ? ${accessor} : ${defaultValue}` : `${valid} ? ${accessor} : undefined`;
+    }
+    // Handle $ref - resolve and validate against the referenced schema
+    if (hasRef(schema) && rootSchema) {
+        const ref = schema.$ref;
+        // If we have already visited this ref, we have a circular reference - return accessor to break cycle
+        if (visitedRefs?.has(ref)) {
+            return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+        }
+        const resolvedSchema = resolveRef(ref, rootSchema);
+        if (resolvedSchema) {
+            const visited = new Set(visitedRefs);
+            visited.add(ref);
+            return generateValidationExpression(key, resolvedSchema, defaultValue, isRequired, rootSchema, visited);
+        }
+    }
+    // Handle union types (oneOf, anyOf)
+    if (hasOneOf(schema) && schema.oneOf.length > 0) {
+        const discriminator = findDiscriminator(schema.oneOf);
+        if (discriminator) {
+            return generateDiscriminatedUnionValidation(accessor, schema.oneOf, discriminator, defaultValue, isRequired);
+        }
+        return generateNonDiscriminatedUnionValidation(accessor, schema.oneOf, defaultValue, isRequired);
+    }
+    if (hasAnyOf(schema) && schema.anyOf.length > 0) {
+        const discriminator = findDiscriminator(schema.anyOf);
+        if (discriminator) {
+            return generateDiscriminatedUnionValidation(accessor, schema.anyOf, discriminator, defaultValue, isRequired);
+        }
+        return generateNonDiscriminatedUnionValidation(accessor, schema.anyOf, defaultValue, isRequired);
+    }
+    // Handle allOf (intersection - all schemas must match)
+    if (hasAllOf(schema) && schema.allOf.length > 0) {
+        const allChecks = [];
+        for (const subSchema of schema.allOf) {
+            const subChecks = generateSchemaChecks(accessor, subSchema);
+            allChecks.push(...subChecks);
+        }
+        if (allChecks.length > 0) {
+            let combinedCheck = allChecks[0];
+            for (let i = 1; i < allChecks.length; i++) {
+                combinedCheck += ' && ' + allChecks[i];
+            }
+            return `${combinedCheck} ? ${accessor} : ${defaultValue}`;
+        }
+        return `${accessor} ?? ${defaultValue}`;
+    }
+    // Handle not (negation - value must NOT match this schema)
+    if ('not' in schema && schema.not) {
+        const notChecks = generateSchemaChecks(accessor, schema.not);
+        if (notChecks.length > 0) {
+            let combinedNotCheck = notChecks[0];
+            for (let i = 1; i < notChecks.length; i++) {
+                combinedNotCheck += ' && ' + notChecks[i];
+            }
+            return `!(${combinedNotCheck}) ? ${accessor} : ${defaultValue}`;
+        }
+    }
+    // Handle const — single exact value that must match
+    if (hasConst(schema)) {
+        const constLiteral = JSON.stringify(schema.const);
+        return isRequired
+            ? `${accessor} === ${constLiteral} ? ${accessor} : ${constLiteral}`
+            : `${accessor} === ${constLiteral} ? ${accessor} : (${accessor} !== undefined ? ${constLiteral} : undefined)`;
+    }
+    if (!hasType(schema) && !hasEnum(schema)) {
+        return `${accessor} ?? ${defaultValue}`;
+    }
+    // Build type-specific checks
+    if (hasType(schema)) {
+        switch (schema.type) {
+            case 'string': {
+                checks.push(`typeof ${accessor} === "string"`);
+                if (hasPattern(schema)) {
+                    checks.push(`/${schema.pattern.replace(/\//g, '\\/')}/.test(${accessor})`);
+                }
+                if (hasMinLength(schema)) {
+                    checks.push(`${accessor}.length >= ${schema.minLength}`);
+                }
+                if (hasMaxLength(schema)) {
+                    checks.push(`${accessor}.length <= ${schema.maxLength}`);
+                }
+                break;
+            }
+            case 'number':
+            case 'integer': {
+                checks.push(`typeof ${accessor} === "number"`);
+                if (hasMinimum(schema)) {
+                    checks.push(`${accessor} >= ${schema.minimum}`);
+                }
+                if (hasMaximum(schema)) {
+                    checks.push(`${accessor} <= ${schema.maximum}`);
+                }
+                if (hasExclusiveMinimum(schema)) {
+                    checks.push(`${accessor} > ${schema.exclusiveMinimum}`);
+                }
+                if (hasExclusiveMaximum(schema)) {
+                    checks.push(`${accessor} < ${schema.exclusiveMaximum}`);
+                }
+                if (hasMultipleOf(schema)) {
+                    checks.push(`${accessor} % ${schema.multipleOf} === 0`);
+                }
+                break;
+            }
+            case 'boolean':
+                checks.push(`typeof ${accessor} === "boolean"`);
+                break;
+            case 'array': {
+                checks.push(`Array.isArray(${accessor})`);
+                if (hasMinItems(schema)) {
+                    checks.push(`${accessor}.length >= ${schema.minItems}`);
+                }
+                if (hasMaxItems(schema)) {
+                    checks.push(`${accessor}.length <= ${schema.maxItems}`);
+                }
+                if (hasUniqueItems(schema) && schema.uniqueItems === true) {
+                    checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+                }
+                break;
+            }
+            case 'object': {
+                checks.push(`isObject(${accessor})`);
+                // Check required properties exist
+                if (hasRequired(schema) && schema.required.length > 0) {
+                    for (const requiredKey of schema.required) {
+                        checks.push(`"${requiredKey}" in ${accessor}`);
+                    }
+                }
+                // Check minProperties
+                if (hasMinProperties(schema)) {
+                    checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
+                }
+                // Check maxProperties
+                if (hasMaxProperties(schema)) {
+                    checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
+                }
+                // Check additionalProperties
+                if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
+                    const allowedKeys = Object.keys(schema.properties);
+                    const allowedKeysStr = JSON.stringify(allowedKeys);
+                    checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
+                }
+                break;
+            }
+        }
+    }
+    // Add enum check if present
+    if (hasEnum(schema) && schema.enum.length > 0) {
+        checks.push(generateEnumCheck(accessor, schema.enum));
+    }
+    // Combine all checks
+    if (checks.length === 0) {
+        return isRequired ? `${accessor} ?? ${defaultValue}` : accessor;
+    }
+    let combinedCheck = checks[0];
+    for (let i = 1; i < checks.length; i++) {
+        combinedCheck += ' && ' + checks[i];
+    }
+    // Generate the fallback value
+    // If the value exists but fails validation, try to coerce it
+    // If the value is missing and required, use the default
+    const typeCoercion = getTypeCoercion(accessor, schema, defaultValue);
+    if (isRequired) {
+        // For required fields: valid ? use_value : (exists ? coerce : default)
+        if (typeCoercion) {
+            // If we know the value is not undefined (e.g., we're inside an undefined check),
+            // we can skip the redundant undefined check
+            if (knownNotUndefined) {
+                return `${combinedCheck} ? ${accessor} : ${typeCoercion}`;
+            }
+            return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : ${defaultValue})`;
+        }
+        return `${combinedCheck} ? ${accessor} : ${defaultValue}`;
+    }
+    else {
+        // For optional fields: valid ? use_value : (exists ? coerce : undefined)
+        if (typeCoercion) {
+            // If we know the value is not undefined, we can skip the check and just coerce
+            if (knownNotUndefined) {
+                return `${combinedCheck} ? ${accessor} : ${typeCoercion}`;
+            }
+            return `${combinedCheck} ? ${accessor} : (${accessor} !== undefined ? ${typeCoercion} : undefined)`;
+        }
+        return `${combinedCheck} ? ${accessor} : undefined`;
+    }
+};

package/dist/helpers/apply-schema-extensions.d.ts

@@ -1,5 +1,5 @@
 import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-import type { SchemaExtensions } from '#types/schema-extensions';
+import type { SchemaExtensions } from '../types/schema-extensions.js';
 /**
  * Merges custom extension properties into a schema's properties based on the
  * definition name. Extension properties are added as optional (not included
@@ -33,3 +33,4 @@ import type { SchemaExtensions } from '#types/schema-extensions';
  * ```
  */
 export declare const applySchemaExtensions: (schema: JSONSchema, definitionName: string, extensions: SchemaExtensions) => JSONSchema;
+//# sourceMappingURL=apply-schema-extensions.d.ts.map

package/dist/helpers/apply-schema-extensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-schema-extensions.d.ts","sourceRoot":"","sources":["../../src/helpers/apply-schema-extensions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iCAAiC,CAAA;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,qBAAqB,WACxB,UAAU,kBACF,MAAM,cACV,gBAAgB,KAC3B,UAuBF,CAAA"}

package/dist/helpers/apply-schema-extensions.js

@@ -0,0 +1,51 @@
+/**
+ * Merges custom extension properties into a schema's properties based on the
+ * definition name. Extension properties are added as optional (not included
+ * in the required array) since they are custom additions that may not always
+ * be present.
+ *
+ * If the schema is not an object, has no matching extensions, or the
+ * extensions record is empty, the original schema is returned unchanged.
+ *
+ * @param schema - The JSON Schema to extend
+ * @param definitionName - The name of the definition (e.g., "parameter")
+ * @param extensions - The extensions configuration mapping definition names to properties
+ * @returns A new schema with extension properties merged in, or the original if unchanged
+ *
+ * @example
+ * ```typescript
+ * const schema = {
+ *   type: 'object',
+ *   properties: { name: { type: 'string' } },
+ *   required: ['name'],
+ * }
+ *
+ * const extensions = {
+ *   parameter: {
+ *     'x-enabled': { type: 'boolean' },
+ *   },
+ * }
+ *
+ * const extended = applySchemaExtensions(schema, 'parameter', extensions)
+ * // extended.properties now includes 'x-enabled' alongside 'name'
+ * ```
+ */
+export const applySchemaExtensions = (schema, definitionName, extensions) => {
+    const extensionProperties = extensions[definitionName];
+    if (!extensionProperties || Object.keys(extensionProperties).length === 0) {
+        return schema;
+    }
+    if (typeof schema !== 'object' || schema === null) {
+        return schema;
+    }
+    const existingProperties = 'properties' in schema && typeof schema.properties === 'object' && schema.properties !== null
+        ? schema.properties
+        : {};
+    return {
+        ...schema,
+        properties: {
+            ...existingProperties,
+            ...extensionProperties,
+        },
+    };
+};

package/dist/helpers/collect-helpers.d.ts

@@ -21,3 +21,4 @@ export type CollectedHelpers = {
  *   `_helpers/` directory at the output root.
  */
 export declare const collectHelpers: (parserFunction: string, mode: HelpersMode, helpersImportPrefix?: string) => CollectedHelpers;
+//# sourceMappingURL=collect-helpers.d.ts.map

package/dist/helpers/collect-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-helpers.d.ts","sourceRoot":"","sources":["../../src/helpers/collect-helpers.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,GAAG,iBAAiB,GAAG,SAAS,CAAA;AAE9F,sEAAsE;AACtE,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,UAAU,CAAA;AAEhD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,iBAAiB,CAAC,CAAA;CACtC,CAAA;AAoBD;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,mBACT,MAAM,QAChB,WAAW,mCAEhB,gBA+BF,CAAA"}