@amritk/generate-parsers 0.17.2 → 0.19.0

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

@@ -1,8 +1,10 @@
-import { escapeRegexPattern } from "@amritk/helpers/escape-regex-pattern";
+import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { getMjstInstanceOf, getMjstPrimitive } from "@amritk/helpers/mjst-extension";
 import { multipleOfPassExpr } from "@amritk/helpers/multiple-of-check";
+import { hasOwnCheck } from "@amritk/helpers/safe-accessor";
 import { hasAdditionalProperties, hasConst, hasEnum, hasExclusiveMaximum, hasExclusiveMinimum, hasMaxItems, hasMaximum, hasMaxLength, hasMaxProperties, hasMinItems, hasMinimum, hasMinLength, hasMinProperties, hasMultipleOf, hasPattern, hasProperties, hasRequired, hasType, hasUniqueItems, isSchemaObject } from "@amritk/helpers/schema-guards";
 import { generateEnumCheck } from "./generate-enum-check.js";
+import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
 const OBJECT_KEYWORDS = [
   "properties",
   "required",
@@ -61,7 +63,7 @@ const generateInferredChecks = (accessor, schema, type) => {
       checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
       if (hasRequired(schema) && schema.required.length > 0) {
         for (const requiredKey of schema.required) {
-          checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+          checks.push(hasOwnCheck(accessor, requiredKey));
         }
       }
       if (hasMinProperties(schema)) {
@@ -84,13 +86,13 @@ const generateInferredChecks = (accessor, schema, type) => {
         checks.push(`${accessor}.length <= ${schema.maxItems}`);
       }
       if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+        checks.push(generateUniqueItemsCheck(accessor, schema));
       }
       break;
     case "string":
       checks.push(`typeof ${accessor} === "string"`);
       if (hasPattern(schema)) {
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+        checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
       }
       if (hasMinLength(schema)) {
         checks.push(`${accessor}.length >= ${schema.minLength}`);
@@ -145,7 +147,7 @@ const generateSchemaChecks = (accessor, schema) => {
     }
     checks.push(...generateInferredChecks(accessor, schema, inferred));
     if (hasEnum(schema) && schema.enum.length > 0) {
-      checks.push(`${JSON.stringify(schema.enum)}.includes(${accessor} as never)`);
+      checks.push(generateEnumCheck(accessor, schema.enum));
     }
     return checks;
   }
@@ -153,7 +155,7 @@ const generateSchemaChecks = (accessor, schema) => {
     case "string": {
       checks.push(`typeof ${accessor} === "string"`);
       if (hasPattern(schema)) {
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${accessor})`);
+        checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
       }
       if (hasMinLength(schema)) {
         checks.push(`${accessor}.length >= ${schema.minLength}`);
@@ -197,14 +199,14 @@ const generateSchemaChecks = (accessor, schema) => {
         checks.push(`${accessor}.length <= ${schema.maxItems}`);
       }
       if (hasUniqueItems(schema) && schema.uniqueItems === true) {
-        checks.push(`new Set(${accessor}).size === ${accessor}.length`);
+        checks.push(generateUniqueItemsCheck(accessor, schema));
       }
       break;
     case "object": {
       checks.push(`typeof ${accessor} === "object" && ${accessor} !== null && !Array.isArray(${accessor})`);
       if (hasRequired(schema) && schema.required.length > 0) {
         for (const requiredKey of schema.required) {
-          checks.push(`${JSON.stringify(requiredKey)} in ${accessor}`);
+          checks.push(hasOwnCheck(accessor, requiredKey));
         }
       }
       if (hasMinProperties(schema)) {

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:
@@ -46,9 +122,17 @@ export declare const generateObjectKeywordChecks: (obj: string, schema: JSONSche
  * Properties with a `$ref` are validated by the nested parser's own strict
  * check when that parser is invoked downstream.
  */
+/**
+ * The `allOf` members this assertion must enforce itself: plain object schemas
+ * written inline. A `$ref` member is enforced by the parser generated for its
+ * target, and a member that composes further (nested `allOf`/`oneOf`/`if`) is
+ * left alone rather than half-checked.
+ */
+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;