@amritk/validation 0.2.0

package/dist/validators/generators/generate-validator-function.d.ts

@@ -0,0 +1,58 @@
+import { type UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * Generates the exported boolean guard `isTypeName`.
+ *
+ * Unlike `validateTypeName` (which returns rich `ValidationResult` errors), this
+ * is a single flat boolean predicate — no error array, no cold-path call — so V8
+ * inlines it like a hand-written `check`, matching the shape of TypeBox's
+ * compiled checker. It returns the *same verdict* as the validator. When the
+ * schema carries anything the flat form can't mirror exactly, it falls back to
+ * `validateTypeName(input) === true`, which is always correct.
+ *
+ * The signature is `input is TypeName` whenever that narrowing is sound, and a
+ * plain `boolean` when it is not — see {@link typeDescribesEveryAcceptedValue}.
+ *
+ * `unknownKeys` picks how a closed object's no-extras test counts keys — see
+ * {@link UnknownKeysStrategy}.
+ */
+export declare const generateBooleanGuard: (schema: JSONSchema, typeName: string, _suffix?: string, unknownKeys?: UnknownKeysStrategy, formats?: ReadonlySet<string>) => string;
+/**
+ * Generates a TypeScript validator function from a JSON Schema.
+ *
+ * The generated function accepts `unknown` input and returns `true` if valid,
+ * or `{ valid: false, errors }` with a list of errors if not.
+ *
+ * Object schemas check that required properties are present and that all
+ * provided properties match their declared types. Non-object schemas (strings,
+ * numbers, enums, $refs) emit an inline type check.
+ *
+ * @example
+ * ```typescript
+ * generateValidatorFunction({ type: 'object', properties: { name: { type: 'string' } }, required: ['name'] }, 'Info')
+ * // export const validateInfo = (input: unknown, _path = ''): ValidationResult => {
+ * //   if (typeof input !== 'object' || ...) return { valid: false, ... }
+ * //   const errors: ValidationError[] = []
+ * //   const obj = input as Record<string, unknown>
+ * //   if (!('name' in obj)) { errors.push(...) } else if (typeof obj['name'] !== 'string') { errors.push(...) }
+ * //   return errors.length > 0 ? { valid: false, errors } : true
+ * // }
+ * ```
+ */
+export declare const generateValidatorFunction: (schema: JSONSchema, typeName: string, suffix?: string, rootSchema?: Record<string, unknown>, unknownKeys?: UnknownKeysStrategy, formats?: ReadonlySet<string>, branchErrors?: boolean) => string;
+/**
+ * Generates the fail-fast half: a `checkX(input, _path?)` that returns the same
+ * `ValidationResult` as `validateX` and stops at the first violation, so the
+ * `errors` array it hands back holds exactly one error — the one `validateX`
+ * would have reported first.
+ *
+ * Same return type on purpose. A caller that already renders a `ValidationResult`
+ * renders this one with the code it has; the only difference is how much of the
+ * document was looked at before the answer came back.
+ *
+ * A schema whose emitted body would report with no runtime condition in front of
+ * it cannot take this shape — see {@link FailFast} — so for those `checkX` runs
+ * `validateX` and hands back its first error. The verdict is identical either
+ * way; only the short circuit is lost.
+ */
+export declare const generateCheckFunction: (schema: JSONSchema, typeName: string, suffix?: string, rootSchema?: Record<string, unknown>, unknownKeys?: UnknownKeysStrategy, formats?: ReadonlySet<string>) => string;