@amritk/generate-parsers 0.18.0 → 0.19.1

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

@@ -14,6 +14,74 @@ export type StrictAssertionContext = {
     readonly rootSchema?: Record<string, unknown>;
     readonly stripUnknown?: boolean;
 };
+/**
+ * Why a node needs the whole-schema backstop, or `null` when the specialized
+ * assertions above already cover it. Each reason is a keyword whose enforcement
+ * no per-property / per-type check can express:
+ *
+ *  - `unevaluated*` depends on which *other* keywords evaluated which keys, so it
+ *    can only be answered against the whole node at once.
+ *  - a `$ref` is normally enforced by the parser generated for its target, but
+ *    that delegation covers neither an inlined build (no ref imports) nor the
+ *    2020-12 rule that a `$ref`'s *siblings* still apply.
+ *  - `items: false` (with no tuple positions) admits only the empty array, and
+ *    the item-check builder reads `items` through a guard that a boolean fails.
+ *  - a constraint keyword with no `type` never reaches the typed constraint pass.
+ */
+export declare const backstopReason: (schema: JSONSchema, context: StrictAssertionContext) => string | null;
+/**
+ * The slice of a node the backstop actually has to prove.
+ *
+ * `unevaluated*` and `$ref` need the node whole — the first because its answer
+ * depends on what every sibling keyword evaluated, the second because a ref's
+ * siblings apply alongside its target. A bare constraint needs only itself, and
+ * proving it in isolation is what keeps an ordinary
+ * `{ allOf: [{…}, { $ref: … }], required: ['role'] }` — the OpenAPI idiom —
+ * generating: the `required` is provable even when the surrounding `allOf`
+ * member is too deep (or too unresolvable) to inline, and that member has its
+ * own enforcement anyway.
+ *
+ * `properties` rides along, flattened to `true` schemas, only because
+ * `additionalProperties` needs the declared key names to know which keys it
+ * owns. Their values are irrelevant to that question and are asserted
+ * per-property elsewhere.
+ */
+export declare const backstopSchema: (schema: JSONSchema, reason: string) => JSONSchema;
+/**
+ * The strict-mode backstop: a single whole-node match, emitted only for the
+ * keywords {@link backstopReason} identifies as unreachable by the specialized
+ * assertions. It is the same exact matcher `contains` and `propertyNames` use, so
+ * a `true` verdict means valid and a `false` one means invalid — which is what
+ * lets it stand alone as the enforcement for those keywords.
+ *
+ * Emitting nothing here is only safe because `assertNoUnsupportedKeywords`
+ * refuses generation for any node that needs a backstop the matcher cannot
+ * build.
+ */
+export declare const generateBackstopAssertion: (acc: string, schema: JSONSchema, label: string, context: StrictAssertionContext, optional?: boolean) => string[];
+/**
+ * Strict-mode `minProperties` / `maxProperties`. Both were read by the coercing
+ * expression builder and the subschema matcher but by nothing on the strict
+ * path, so a strict parser accepted `{}` against `{ minProperties: 2 }` — at the
+ * root, on a property, and inside the empty-object/record parsers alike. `guard`
+ * wraps the comparison in a runtime `isObject` for accessors whose type is
+ * reported separately; callers that have already proven an object pass `false`.
+ */
+export declare const generateObjectSizeChecks: (acc: string, schema: JSONSchema, label: string, guard: boolean) => string[];
+/**
+ * Strict-mode value checks for keys the schema constrains by *pattern* rather
+ * than by name: `patternProperties` (every key matching the regex) and a
+ * schema-valued `additionalProperties` (every key matched by neither
+ * `properties` nor a pattern). Both were read only by the *building* code paths
+ * — which coerce or copy — so a strict parser accepted `{ s_a: 1 }` against
+ * `patternProperties: { '^s_': { type: 'string' } }`.
+ *
+ * One `Object.keys` walk covers both, and a term is emitted only when
+ * {@link subschemaMatchExpr} proves its subschema exactly. `additionalProperties:
+ * false` is not handled here — that is the unknown-key rejection the parsers
+ * already emit.
+ */
+export declare const generateKeyedValueChecks: (obj: string, schema: JSONSchema, label: string, context?: StrictAssertionContext) => string[];
 /**
  * Strict-mode `contains` / `minContains` / `maxContains`: at least `minContains`
  * (default 1) and at most `maxContains` (default ∞) items of the array must
@@ -24,7 +92,15 @@ export type StrictAssertionContext = {
  * `contains` or its subschema is not matchable inline (the generation-time guard
  * rejects the latter, so a strict parser never silently drops the constraint).
  */
-export declare const generateContainsCheck: (acc: string, schema: JSONSchema, label: string) => string[];
+export declare const generateContainsCheck: (acc: string, schema: JSONSchema, label: string, context?: StrictAssertionContext) => string[];
+/**
+ * The composition checks (`not`, `allOf`, `if`/`then`/`else`) for a value the
+ * caller has already proven present. Exported for the specialized object parsers
+ * (empty-object, pattern-properties, additionalProperties), which build their
+ * result outside {@link generateObjectStrictAssertion} and so would otherwise
+ * emit no composition check at all.
+ */
+export declare const generateCompositionChecks: (acc: string, schema: JSONSchema, label: string, context?: StrictAssertionContext) => string[];
 /**
  * Emits the object-level keyword checks (`dependentRequired`, `dependentSchemas`,
  * `propertyNames`) for the object reached by `obj`. When `guard` is true the
@@ -34,7 +110,7 @@ export declare const generateContainsCheck: (acc: string, schema: JSONSchema, la
  * `guard = false` because the enclosing parser has already proven the value is
  * an object.
  */
-export declare const generateObjectKeywordChecks: (obj: string, schema: JSONSchema, label: string, guard: boolean) => string[];
+export declare const generateObjectKeywordChecks: (obj: string, schema: JSONSchema, label: string, guard: boolean, context?: StrictAssertionContext) => string[];
 /**
  * Generates strict-mode assertions for the body of an object parser.
  * Throws on:
@@ -55,7 +131,8 @@ export declare const generateObjectKeywordChecks: (obj: string, schema: JSONSche
 export declare const inlineAllOfMembers: (schema: JSONSchema) => JSONSchema[];
 export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeName: string, context?: StrictAssertionContext) => string[];
 /**
- * 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.
+ * Generates the strict-mode assertion lines for a non-object (scalar, array,
+ * type-less) parser. Returns null when the schema constrains nothing this
+ * generator can assert on, which is the caller's cue to emit a bare cast.
  */
-export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string, rootSchema?: Record<string, unknown>) => string | null;
+export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string, context?: StrictAssertionContext) => string | null;