@amritk/generate-parsers 0.22.0 → 0.24.0

package/README.md

@@ -331,7 +331,7 @@ each schema in the official
 (the required Draft 2020-12 tests — 1281 cases), links the emitted files in
 memory, and runs the suite's instances through the real generated code:
 
-**1240 / 1281 cases pass (96.8%).**
+**1242 / 1281 cases pass (97.0%).**
 
 A case passes only if the parser throws exactly when the spec says invalid *and*
 returns an accepted document unchanged — strict mode does not coerce, so a parser
@@ -343,14 +343,14 @@ no I/O to answer the retrieval step. Everything else — applying the base URIs,
 walking anchors across documents, emitting a parser per definition and an import
 graph that links — the generator still has to do.
 
-Of the 41 that do not, **18** follow from the third departure above — the
+Of the 39 that do not, **18** follow from the third departure above — the
 `ignores a non-object` cases plus three `ref.json` cases where a recursive `$ref`
 lands on a root that declares `properties` — and **12** are a keyword strict mode will not
 approximate (a cyclic `$ref` with siblings, a cyclic `unevaluatedProperties`) —
 those cost a build error naming the cause, never a wrong verdict. The rest: **8**
 `$dynamicRef`s whose binding depends on the evaluation path (a generator emits one
-function per definition, shared by every path that reaches it), **2** embedded
-resources whose definitions reduce to one filename, and one `$vocabulary` case.
+function per definition, shared by every path that reaches it), and one
+`$vocabulary` case.
 
 Every one is listed in
 `src/generators/json-schema-conformance-expected-failures.test-utils.ts` with the

package/dist/generators/generate-files.js

@@ -22,7 +22,8 @@ const generateFile = (schema, typeName, options) => {
       selfFilename: options?.selfFilename,
       rootSchema,
       typeSuffix,
-      importExt
+      importExt,
+      usedIn: typeDefinition
     });
     let result2 = "";
     if (imports2.length > 0) {
@@ -61,7 +62,16 @@ const generateFile = (schema, typeName, options) => {
 ${parserFunction}`;
   const helpers = collectHelpers(combinedFunctions, helpersMode, options?.helpersImportPrefix, importExt);
   const imports = [
-    ...collectImports(schema, { selfRef, selfFilename: options?.selfFilename, rootSchema, typeSuffix, importExt }),
+    ...collectImports(schema, {
+      selfRef,
+      selfFilename: options?.selfFilename,
+      rootSchema,
+      typeSuffix,
+      importExt,
+      // Both halves of the file: the type names the type definition spells and
+      // the functions the emitted code calls are one question about one text.
+      usedIn: typeDefinition + "\n\n" + combinedFunctions
+    }),
     ...helpers.imports
   ];
   let result = "";

package/dist/generators/generate-parser-function.js

@@ -1,6 +1,7 @@
 import { regexLiteral } from "@amritk/helpers/escape-regex-pattern";
 import { generateTypeDefinition } from "@amritk/helpers/generate-type-definition";
 import { quoteJsString } from "@amritk/helpers/quote-js-string";
+import { declaresKey, readKey } from "@amritk/helpers/read-key";
 import { refToName } from "@amritk/helpers/ref-to-name";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
 import { hasOwnCheck, missingCheck, safeAccessor, safeKey } from "@amritk/helpers/safe-accessor";
@@ -208,7 +209,10 @@ const generateFallbackObject = (schema, useRefImports, typeName, suffix, subType
     }
   }
   result += "\n      }";
-  return declaresPrototypeMemberProperty(schema) ? `${result} as unknown as ${typeName}` : result;
+  if (declaresPrototypeMemberProperty(schema))
+    return `${result} as unknown as ${typeName}`;
+  const composesUnion = isSchemaObject(schema) && (hasOneOf(schema) || hasAnyOf(schema));
+  return composesUnion ? `${result} as ${typeName}` : result;
 };
 const SCALAR_ROOT_CONSTRAINTS = [
   "pattern",
@@ -1699,14 +1703,28 @@ const getConditionalObjectSchema = (schema) => {
     ...required.size > 0 ? { required: Array.from(required) } : {}
   };
 };
-const generateSchemaObjectParser = (typeName) => {
+const OBJECT_SHAPE_KEYWORDS = ["properties", "patternProperties", "additionalProperties", "required"];
+const DELEGATING_KEYWORDS = ["$ref", "$dynamicRef", "allOf", "anyOf", "oneOf", "if", "not"];
+const admitsBooleanSchema = (schema) => {
+  if (typeof schema === "boolean")
+    return true;
+  if (!isSchemaObject(schema))
+    return false;
+  const record = schema;
+  const type = readKey(record, "type");
+  if (type !== void 0)
+    return Array.isArray(type) ? type.includes("boolean") : type === "boolean";
+  return ![...OBJECT_SHAPE_KEYWORDS, ...DELEGATING_KEYWORDS].some((keyword) => declaresKey(record, keyword));
+};
+const generateSchemaObjectParser = (typeName, schema) => {
   const functionName = generateParserName(typeName);
-  return `export const ${functionName} = (input: unknown): ${typeName} => {
-  if (typeof input === 'boolean') {
+  const booleanBranch = admitsBooleanSchema(schema) ? `  if (typeof input === 'boolean') {
     return input as ${typeName};
   }
   
-  if (!isObject(input)) {
+` : "";
+  return `export const ${functionName} = (input: unknown): ${typeName} => {
+${booleanBranch}  if (!isObject(input)) {
     return {} as ${typeName};
   }
   
@@ -1730,7 +1748,7 @@ const selectParserStrategy = (schema, typeName, options) => {
   };
   const copyLoopContext = { ...context, subParsers: false };
   if (!options?.isRoot && typeName === `Schema${suffix}`) {
-    return generateSchemaObjectParser(typeName);
+    return generateSchemaObjectParser(typeName, schema);
   }
   const isObjectLikeSchema = isObjectSchema(schema) || isSchemaObject(schema) && ("patternProperties" in schema || "additionalProperties" in schema);
   if (!isObjectLikeSchema && !isSchemaObject(schema)) {

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

@@ -42,6 +42,17 @@ type CollectImportsOptions = {
      * type stripping.
      */
     readonly importExt?: ImportExtension;
+    /**
+     * The file body this import list is being written above. When given, only the
+     * `$ref` imports whose names the body actually spells are emitted, and one
+     * whose parser is never called is narrowed to a type-only import.
+     *
+     * The walk below can only approximate what the emitters wrote: it stops at a
+     * `$ref` the type emitter inlines *through*, and it cannot see a branch that
+     * folded away. Asking the emitted text settles both directions, the way
+     * `collectHelpers` already settles which runtime helpers a file needs.
+     */
+    readonly usedIn?: string | undefined;
 };
 /**
  * Collects all import statements needed for a schema by finding $ref references

package/dist/helpers/collect-imports.js

@@ -1,16 +1,28 @@
+import { identifierMentions } from "@amritk/helpers/identifier-mentions";
+import { readKey } from "@amritk/helpers/read-key";
 import { refToFilename } from "@amritk/helpers/ref-to-filename";
 import { refToName } from "@amritk/helpers/ref-to-name";
+import { referencedConditional } from "@amritk/helpers/referenced-conditional";
 import { resolveRef } from "@amritk/helpers/resolve-ref";
-import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from "@amritk/helpers/schema-guards";
+import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef, isSchemaObject } from "@amritk/helpers/schema-guards";
 const getImportPathForFilename = (filename, ext) => `./${filename}.${ext}`;
 const collectImports = (schema, options) => {
   const typesOnly = options?.typesOnly === true;
   const importExt = options?.importExt ?? "js";
   const importMap = /* @__PURE__ */ new Map();
+  const mentions = options?.usedIn === void 0 ? () => true : identifierMentions(options.usedIn);
   for (const [filename, { typeName, typeOnly }] of collectImportTargets(schema, options)) {
     const importPath = getImportPathForFilename(filename, importExt);
-    const importStatement = typesOnly || typeOnly ? `import type { ${typeName} } from '${importPath}';` : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
-    importMap.set(filename, importStatement);
+    const values = typesOnly || typeOnly ? [] : [`parse${typeName}`, `validate${typeName}Shape`].filter((name) => mentions(name));
+    const named = mentions(typeName);
+    if (values.length === 0) {
+      if (!named)
+        continue;
+      importMap.set(filename, `import type { ${typeName} } from '${importPath}';`);
+      continue;
+    }
+    const specifiers = named ? [`type ${typeName}`, ...values] : values;
+    importMap.set(filename, `import { ${specifiers.join(", ")} } from '${importPath}';`);
   }
   return Array.from(importMap.values()).sort();
 };
@@ -27,6 +39,24 @@ const collectImportTargets = (schema, options) => {
   const refs = /* @__PURE__ */ new Set();
   const valueRefs = /* @__PURE__ */ new Set();
   let typeOnlyDepth = 0;
+  const inlinedRefs = /* @__PURE__ */ new Set();
+  const collectRefsFromAllOfMember = (entry) => {
+    collectRefsFromValue(entry);
+    const ref = isSchemaObject(entry) ? readKey(entry, "$ref") : void 0;
+    if (typeof ref === "string" && inlinedRefs.has(ref))
+      return;
+    const inlined = referencedConditional(entry, rootSchema);
+    if (inlined === void 0)
+      return;
+    if (typeof ref === "string")
+      inlinedRefs.add(ref);
+    typeOnlyDepth++;
+    for (const arm of ["if", "then", "else"]) {
+      if (Object.hasOwn(inlined, arm))
+        collectRefsFromValue(readKey(inlined, arm));
+    }
+    typeOnlyDepth--;
+  };
   const collectRefsFromValue = (value) => {
     if (typeof value !== "object" || value === null) {
       return;
@@ -87,7 +117,7 @@ const collectImportTargets = (schema, options) => {
     }
     if (hasAllOf(record)) {
       for (const item of record.allOf) {
-        collectRefsFromValue(item);
+        collectRefsFromAllOfMember(item);
       }
     }
     if (hasItems(record) && !Array.isArray(record.items)) {
@@ -163,7 +193,7 @@ const collectImportTargets = (schema, options) => {
   }
   if (typeof schema === "object" && schema !== null && hasAllOf(schema)) {
     for (const item of schema.allOf) {
-      collectRefsFromValue(item);
+      collectRefsFromAllOfMember(item);
     }
   }
   if (typeof schema === "object" && schema !== null && Object.hasOwn(schema, "if")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -60,10 +60,10 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "^0.20.0"
+    "@amritk/helpers": "^0.22.0"
   },
   "devDependencies": {
-    "@amritk/generate-markdown": "^0.6.0",
+    "@amritk/generate-markdown": "^0.8.0",
     "@sinclair/typebox": "^0.34.49",
     "ajv": "^8.17.1",
     "benny": "^3.7.1",