@amritk/generate-parsers 0.24.0 → 0.25.0

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

@@ -1,5 +0,0 @@
-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[];

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

@@ -1,260 +0,0 @@
-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 { boundPassExpr } from "@amritk/helpers/numeric-bound-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 { maxLengthPassExpr, minLengthPassExpr } from "@amritk/helpers/string-length-check";
-import { generateDeepEqualCheck } from "./generate-deep-equal-check.js";
-import { generateEnumCheck } from "./generate-enum-check.js";
-import { generateUniqueItemsCheck } from "./generate-unique-items-check.js";
-const OBJECT_KEYWORDS = [
-  "properties",
-  "required",
-  "minProperties",
-  "maxProperties",
-  "additionalProperties",
-  "patternProperties",
-  "dependentRequired",
-  "propertyNames"
-];
-const ARRAY_KEYWORDS = ["items", "prefixItems", "minItems", "maxItems", "uniqueItems", "contains"];
-const STRING_KEYWORDS = ["minLength", "maxLength", "pattern", "format"];
-const NUMBER_KEYWORDS = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"];
-const countKeywords = (schema, keywords) => keywords.reduce((total, keyword) => keyword in schema ? total + 1 : total, 0);
-const typeOfLiteral = (value) => {
-  if (value === null)
-    return "null";
-  if (Array.isArray(value))
-    return "array";
-  const type = typeof value;
-  if (type === "boolean")
-    return "boolean";
-  if (type === "number" || type === "bigint")
-    return "number";
-  if (type === "string")
-    return "string";
-  return "object";
-};
-const inferSchemaType = (schema) => {
-  if (!isSchemaObject(schema))
-    return void 0;
-  if (hasConst(schema)) {
-    return typeOfLiteral(schema.const);
-  }
-  if (hasEnum(schema) && schema.enum.length > 0 && schema.enum.every((value) => value === null)) {
-    return "null";
-  }
-  const scores = {
-    object: countKeywords(schema, OBJECT_KEYWORDS),
-    array: countKeywords(schema, ARRAY_KEYWORDS),
-    string: countKeywords(schema, STRING_KEYWORDS),
-    number: countKeywords(schema, NUMBER_KEYWORDS)
-  };
-  let best;
-  for (const type of ["object", "array", "string", "number"]) {
-    if (scores[type] > 0 && (best === void 0 || scores[type] > scores[best])) {
-      best = type;
-    }
-  }
-  return best;
-};
-const generateInferredChecks = (accessor, schema, type) => {
-  const checks = [];
-  switch (type) {
-    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(hasOwnCheck(accessor, requiredKey));
-        }
-      }
-      if (hasMinProperties(schema)) {
-        checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
-      }
-      if (hasMaxProperties(schema)) {
-        checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
-      }
-      if (hasAdditionalProperties(schema) && schema.additionalProperties === false && hasProperties(schema)) {
-        const allowedKeysStr = JSON.stringify(Object.keys(schema.properties));
-        checks.push(`Object.keys(${accessor}).every(k => ${allowedKeysStr}.includes(k))`);
-      }
-      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(generateUniqueItemsCheck(accessor, schema));
-      }
-      break;
-    case "string":
-      checks.push(`typeof ${accessor} === "string"`);
-      if (hasPattern(schema)) {
-        checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
-      }
-      if (hasMinLength(schema)) {
-        checks.push(minLengthPassExpr(accessor, schema.minLength));
-      }
-      if (hasMaxLength(schema)) {
-        checks.push(maxLengthPassExpr(accessor, schema.maxLength));
-      }
-      break;
-    case "number":
-      checks.push(`typeof ${accessor} === "number"`);
-      if (hasMinimum(schema)) {
-        checks.push(boundPassExpr(accessor, "minimum", schema.minimum));
-      }
-      if (hasMaximum(schema)) {
-        checks.push(boundPassExpr(accessor, "maximum", schema.maximum));
-      }
-      if (hasExclusiveMinimum(schema)) {
-        checks.push(boundPassExpr(accessor, "minimum", schema.exclusiveMinimum, true));
-      }
-      if (hasExclusiveMaximum(schema)) {
-        checks.push(boundPassExpr(accessor, "maximum", schema.exclusiveMaximum, true));
-      }
-      if (hasMultipleOf(schema)) {
-        checks.push(`${accessor} % ${schema.multipleOf} === 0`);
-      }
-      break;
-    case "boolean":
-      checks.push(`typeof ${accessor} === "boolean"`);
-      break;
-    case "null":
-      if (hasConst(schema)) {
-        checks.push(`${accessor} === null`);
-      }
-      break;
-  }
-  return checks;
-};
-const generateSchemaChecks = (accessor, schema) => {
-  const checks = [];
-  const instanceOf = getMjstInstanceOf(schema);
-  if (instanceOf) {
-    return [`${accessor} instanceof ${instanceOf}`];
-  }
-  const primitive = getMjstPrimitive(schema);
-  if (primitive) {
-    return [`typeof ${accessor} === "${primitive}"`];
-  }
-  if (hasConst(schema)) {
-    return [generateDeepEqualCheck(accessor, schema.const)];
-  }
-  if (isSchemaObject(schema) && Array.isArray(schema.type)) {
-    const branches = [];
-    for (const type of schema.type) {
-      if (typeof type !== "string")
-        continue;
-      const branch = generateSchemaChecks(accessor, { ...schema, type });
-      if (branch.length === 0)
-        continue;
-      branches.push(branch.length === 1 ? branch[0] : `(${branch.join(" && ")})`);
-    }
-    if (branches.length === 0)
-      return checks;
-    return [branches.length === 1 ? branches[0] : `(${branches.join(" || ")})`];
-  }
-  if (!hasType(schema)) {
-    const inferred = inferSchemaType(schema);
-    if (!inferred) {
-      return checks;
-    }
-    checks.push(...generateInferredChecks(accessor, schema, inferred));
-    if (hasEnum(schema) && schema.enum.length > 0) {
-      checks.push(generateEnumCheck(accessor, schema.enum));
-    }
-    return checks;
-  }
-  switch (schema.type) {
-    case "string": {
-      checks.push(`typeof ${accessor} === "string"`);
-      if (hasPattern(schema)) {
-        checks.push(`${regexLiteral(schema.pattern)}.test(${accessor})`);
-      }
-      if (hasMinLength(schema)) {
-        checks.push(minLengthPassExpr(accessor, schema.minLength));
-      }
-      if (hasMaxLength(schema)) {
-        checks.push(maxLengthPassExpr(accessor, schema.maxLength));
-      }
-      break;
-    }
-    case "number":
-    case "integer":
-      checks.push(`typeof ${accessor} === "number"`);
-      if (schema.type === "integer") {
-        checks.push(`Number.isInteger(${accessor})`);
-      }
-      if (hasMinimum(schema)) {
-        checks.push(boundPassExpr(accessor, "minimum", schema.minimum));
-      }
-      if (hasMaximum(schema)) {
-        checks.push(boundPassExpr(accessor, "maximum", schema.maximum));
-      }
-      if (hasExclusiveMinimum(schema)) {
-        checks.push(boundPassExpr(accessor, "minimum", schema.exclusiveMinimum, true));
-      }
-      if (hasExclusiveMaximum(schema)) {
-        checks.push(boundPassExpr(accessor, "maximum", schema.exclusiveMaximum, true));
-      }
-      if (hasMultipleOf(schema)) {
-        checks.push(multipleOfPassExpr(accessor, schema.multipleOf));
-      }
-      break;
-    case "boolean":
-      checks.push(`typeof ${accessor} === "boolean"`);
-      break;
-    // Without this the `null` branch of a union produced NO check, which reads
-    // as "this branch matches nothing": `{ anyOf: [{ type: 'string' },
-    // { type: 'null' }] }` rejected `null` — the one value the branch exists to
-    // admit — and the coercing build dropped the property instead of keeping it.
-    case "null":
-      checks.push(`${accessor} === null`);
-      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(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(hasOwnCheck(accessor, requiredKey));
-        }
-      }
-      if (hasMinProperties(schema)) {
-        checks.push(`Object.keys(${accessor}).length >= ${schema.minProperties}`);
-      }
-      if (hasMaxProperties(schema)) {
-        checks.push(`Object.keys(${accessor}).length <= ${schema.maxProperties}`);
-      }
-      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;
-};
-export {
-  generateSchemaChecks
-};

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

@@ -1,155 +0,0 @@
-import type { UnknownKeysStrategy } from '@amritk/helpers/unknown-keys-strategy';
-import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
-/**
- * Context for assertions that reach beyond the property's own schema: union
- * membership checks may call imported `validate{X}Shape` predicates ($ref
- * branches), which requires knowing the ref-import mode, the type-name suffix,
- * and the root document (to prove those validators are real — see
- * canEnforceUnion). `stripUnknown` disables union enforcement entirely, since
- * shape validators then treat undeclared keys as a mismatch while the
- * stripUnknown contract is to drop them.
- */
-export type StrictAssertionContext = {
-    readonly useRefImports?: boolean;
-    readonly suffix?: string;
-    readonly rootSchema?: Record<string, unknown>;
-    readonly stripUnknown?: boolean;
-    /**
-     * The parser's `unknownKeys` option, carried so every object parser one of
-     * these contexts reaches counts keys on its fast path the same way.
-     */
-    readonly unknownKeys?: UnknownKeysStrategy;
-    /**
-     * Whether the parser these assertions run inside also emits the private
-     * sub-parsers for its inline object properties (and inline-object array
-     * items). `generateObjectParser` does, so the shape of such a property is
-     * proven by the call it delegates to and asserting it here would be
-     * redundant. The pattern-property parsers do NOT — they build their result
-     * with a copy loop — so a nested object property there is proven by nobody
-     * unless these assertions prove it. Defaults to true, the historical
-     * assumption.
-     */
-    readonly subParsers?: 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
- * match the `contains` subschema. Runtime-gated on `Array.isArray` so a
- * non-array value is left to the type check, and wrapped in a block so the
- * per-array count variable never collides with a sibling check. `minContains: 0`
- * makes the lower bound trivially satisfied. Emits nothing when there is no
- * `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, 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
- * whole block is wrapped in a runtime `isObject` check — used for object-typed
- * *properties*, whose value may be absent or a non-object (the type check
- * reports that separately). The root object and inline sub-parsers pass
- * `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, context?: StrictAssertionContext) => string[];
-/**
- * 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.
- */
-/**
- * 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 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, context?: StrictAssertionContext) => string | null;