@amritk/generate-parsers 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,3 +1,8 @@
+// src/generators/build-schema.ts
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, resolve as resolvePath } from "node:path";
+
 // ../helpers/dist/build-dynamic-ref-map.js
 var isSchemaObject = (schema) => {
   return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
@@ -792,24 +797,46 @@ var generateTypeDefinition = (schema, typeName) => {
 };
 
 // src/helpers/collect-helpers.ts
-var collectHelpers = (parserFunction) => {
+var PACKAGE_IMPORTS = {
+  "is-object": "import { isObject } from '@amritk/helpers/is-object';",
+  "validate-array": "import { validateArray } from '@amritk/helpers/validate-array';",
+  "validate-record": "import { validateRecord } from '@amritk/helpers/validate-record';",
+  "has-ref": "import { hasRef } from '@amritk/helpers/schema-guards';"
+};
+var EMBEDDED_IMPORTS = {
+  "is-object": "import { isObject } from './_helpers/is-object';",
+  "validate-array": "import { validateArray } from './_helpers/validate-array';",
+  "validate-record": "import { validateRecord } from './_helpers/validate-record';",
+  "has-ref": "import { hasRef } from './_helpers/has-ref';"
+};
+var collectHelpers = (parserFunction, mode) => {
   const imports = [];
+  const used = new Set;
+  const table = mode === "embedded" ? EMBEDDED_IMPORTS : PACKAGE_IMPORTS;
   if (parserFunction.includes("validateArray")) {
-    imports.push("import { validateArray } from '@amritk/helpers/validate-array';");
+    imports.push(table["validate-array"]);
+    used.add("validate-array");
   }
   if (parserFunction.includes("validateRecord")) {
-    imports.push("import { validateRecord } from '@amritk/helpers/validate-record';");
+    imports.push(table["validate-record"]);
+    used.add("validate-record");
+    used.add("is-object");
   }
   if (parserFunction.includes("isObject")) {
-    imports.push("import { isObject } from '@amritk/helpers/is-object';");
+    imports.push(table["is-object"]);
+    used.add("is-object");
   }
   if (parserFunction.includes("hasRef(")) {
-    imports.push("import { hasRef } from '@amritk/helpers/schema-guards';");
+    imports.push(table["has-ref"]);
+    used.add("has-ref");
   }
-  return imports;
+  return { imports, used };
 };
 
 // ../helpers/dist/schema-guards.js
+var hasRef = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && "$ref" in value && typeof value.$ref === "string";
+};
 var isSchemaObject3 = (schema) => {
   return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
 };
@@ -891,9 +918,6 @@ var hasMinProperties = (schema) => {
 var hasMaxProperties = (schema) => {
   return isSchemaObject3(schema) && "maxProperties" in schema && typeof schema.maxProperties === "number";
 };
-var hasRef = (schema) => {
-  return isSchemaObject3(schema) && "$ref" in schema && typeof schema.$ref === "string";
-};
 
 // src/helpers/collect-imports.ts
 var getImportPathForFilename = (filename) => `./${filename}`;
@@ -1142,6 +1166,119 @@ var getDefaultValue = (schema) => {
   }
 };
 
+// src/generators/generate-strict-assertion.ts
+var wrongTypeCondition = (accessor, type) => {
+  switch (type) {
+    case "string":
+      return `typeof ${accessor} !== "string"`;
+    case "number":
+    case "integer":
+      return `typeof ${accessor} !== "number"`;
+    case "boolean":
+      return `typeof ${accessor} !== "boolean"`;
+    case "array":
+      return `!Array.isArray(${accessor})`;
+    case "object":
+      return `!isObject(${accessor})`;
+    default:
+      return null;
+  }
+};
+var typeLabel = (type) => type === "integer" ? "number" : type;
+var escapeRegexPattern = (pattern) => {
+  return pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
+};
+var generateConstraintChecks = (acc, propSchema, typeName, key) => {
+  if (!isSchemaObject3(propSchema) || !hasType(propSchema))
+    return [];
+  const t = propSchema.type;
+  const lines = [];
+  if (t === "string") {
+    if (hasPattern(propSchema)) {
+      const pattern = escapeRegexPattern(propSchema.pattern);
+      lines.push(`  if (typeof ${acc} === "string" && !/${pattern}/.test(${acc})) throw new Error('[${typeName}] field "${key}" must match pattern ${propSchema.pattern}');`);
+    }
+    if (hasMinLength(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length < ${propSchema.minLength}) throw new Error('[${typeName}] field "${key}" must have at least ${propSchema.minLength} characters');`);
+    }
+    if (hasMaxLength(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "string" && ${acc}.length > ${propSchema.maxLength}) throw new Error('[${typeName}] field "${key}" must have at most ${propSchema.maxLength} characters');`);
+    }
+  }
+  if (t === "number" || t === "integer") {
+    if (hasMinimum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} < ${propSchema.minimum}) throw new Error('[${typeName}] field "${key}" must be >= ${propSchema.minimum}');`);
+    }
+    if (hasMaximum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} > ${propSchema.maximum}) throw new Error('[${typeName}] field "${key}" must be <= ${propSchema.maximum}');`);
+    }
+    if (hasExclusiveMinimum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} <= ${propSchema.exclusiveMinimum}) throw new Error('[${typeName}] field "${key}" must be > ${propSchema.exclusiveMinimum}');`);
+    }
+    if (hasExclusiveMaximum(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} >= ${propSchema.exclusiveMaximum}) throw new Error('[${typeName}] field "${key}" must be < ${propSchema.exclusiveMaximum}');`);
+    }
+    if (hasMultipleOf(propSchema)) {
+      lines.push(`  if (typeof ${acc} === "number" && ${acc} % ${propSchema.multipleOf} !== 0) throw new Error('[${typeName}] field "${key}" must be a multiple of ${propSchema.multipleOf}');`);
+    }
+  }
+  return lines;
+};
+var generatePropertyAssertion = (key, propSchema, isRequired, typeName) => {
+  const acc = safeAccessor("input", key);
+  const lines = [];
+  if (isRequired) {
+    lines.push(`  if (!(${JSON.stringify(key)} in input)) throw new Error('[${typeName}] missing required property "${key}"');`);
+  }
+  if (!isSchemaObject3(propSchema))
+    return lines;
+  if (hasRef(propSchema))
+    return lines;
+  if (hasEnum(propSchema)) {
+    const allowed = JSON.stringify(propSchema.enum);
+    const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
+    if (isRequired) {
+      lines.push(`  if (!(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+    } else {
+      lines.push(`  if (${acc} !== undefined && !(${allowed} as readonly unknown[]).includes(${acc})) throw new Error('[${typeName}] field "${key}" must be one of: ${label}');`);
+    }
+    return lines;
+  }
+  if (hasType(propSchema)) {
+    const t = propSchema.type;
+    const wrongType = wrongTypeCondition(acc, t);
+    if (wrongType) {
+      if (isRequired) {
+        lines.push(`  if (${wrongType}) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+      } else {
+        lines.push(`  if (${acc} !== undefined && (${wrongType})) throw new Error(\`[${typeName}] field "${key}" expected ${typeLabel(t)}, got \${typeof ${acc}}\`);`);
+      }
+    }
+    lines.push(...generateConstraintChecks(acc, propSchema, typeName, key));
+  }
+  return lines;
+};
+var generateObjectStrictAssertion = (schema, typeName) => {
+  const lines = [];
+  lines.push(`  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);`);
+  if (!hasProperties(schema) || !isSchemaObject3(schema))
+    return lines;
+  const required = new Set(hasRequired(schema) ? schema.required : []);
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    lines.push(...generatePropertyAssertion(key, propSchema, required.has(key), typeName));
+  }
+  return lines;
+};
+var generateScalarStrictAssertion = (schema, typeName) => {
+  if (!isSchemaObject3(schema) || !hasType(schema))
+    return null;
+  const t = schema.type;
+  const wrongType = wrongTypeCondition("input", t);
+  if (!wrongType)
+    return null;
+  return `  if (${wrongType}) throw new Error(\`[${typeName}] expected ${typeLabel(t)}, got \${input === null ? "null" : typeof input}\`);`;
+};
+
 // src/helpers/find-discriminator.ts
 var findDiscriminator = (schemas) => {
   const propertyValues = new Map;
@@ -1712,11 +1849,22 @@ var generateFallbackObject = (schema, useRefImports, typeName) => {
       }`;
   return result;
 };
-var generateNonObjectParser = (typeName, schema) => {
+var generateNonObjectParser = (typeName, schema, strict) => {
   const functionName = generateParserName(typeName);
   if (!isSchemaObject3(schema) || !hasType(schema)) {
     return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
   }
+  if (strict) {
+    const assertion = generateScalarStrictAssertion(schema, typeName);
+    if (assertion === null) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
+    }
+    const returnExpr = schema.type === "array" ? `[...(input as readonly unknown[])] as ${typeName}` : `input as ${typeName}`;
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+${assertion}
+  return ${returnExpr};
+};`;
+  }
   switch (schema.type) {
     case "string":
       return `export const ${functionName} = (input: unknown): ${typeName} => typeof input === "string" ? input as ${typeName} : "" as ${typeName};`;
@@ -1731,8 +1879,14 @@ var generateNonObjectParser = (typeName, schema) => {
       return `export const ${functionName} = (input: unknown): ${typeName} => input as ${typeName};`;
   }
 };
-var generateEmptyObjectParser = (typeName) => {
+var generateEmptyObjectParser = (typeName, strict) => {
   const functionName = generateParserName(typeName);
+  if (strict) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return { ...input } as ${typeName};
+};`;
+  }
   return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {} as ${typeName};`;
 };
 var toVarName = (key) => {
@@ -1761,7 +1915,7 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
     case "string": {
       checks.push(`typeof ${varName} === "string"`);
       if (hasPattern(schema))
-        checks.push(`/${escapeRegexPattern(schema.pattern)}/.test(${varName})`);
+        checks.push(`/${escapeRegexPattern2(schema.pattern)}/.test(${varName})`);
       if (hasMinLength(schema))
         checks.push(`${varName}.length >= ${schema.minLength}`);
       if (hasMaxLength(schema))
@@ -1814,16 +1968,28 @@ var generatePropertyTypeCheck = (varName, schema, useRefImports) => {
 var shouldCacheVariable = (propSchema, _canFastPath, _useRefImports) => {
   return isSchemaObject3(propSchema);
 };
-var generateObjectParser = (schema, typeName, useRefImports, logWarnings) => {
+var generateObjectParser = (schema, typeName, useRefImports, logWarnings, strict) => {
   const functionName = generateParserName(typeName);
   if (!hasProperties(schema)) {
+    if (strict) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return input as ${typeName};
+};`;
+    }
     return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? input as ${typeName} : {} as ${typeName};`;
   }
   const fallbackObject = generateFallbackObject(schema, useRefImports, typeName);
   const properties = Object.entries(schema.properties);
   const lines = [];
   lines.push(`export const ${functionName} = (input: unknown): ${typeName} => {`);
-  lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+  if (strict) {
+    for (const assertionLine of generateObjectStrictAssertion(schema, typeName)) {
+      lines.push(assertionLine);
+    }
+  } else {
+    lines.push(`  if (!isObject(input)) return ${fallbackObject};`);
+  }
   const propInfo = [];
   const hasAllOfRefParsers = useRefImports && isSchemaObject3(schema) && hasAllOf(schema) && schema.allOf.some((entry) => isSchemaObject3(entry) && hasRef(entry));
   let canFastPath = !hasAllOfRefParsers;
@@ -1946,7 +2112,7 @@ var generateObjectParser = (schema, typeName, useRefImports, logWarnings) => {
   }
   return result;
 };
-var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings) => {
+var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings, strict) => {
   const functionName = generateParserName(typeName);
   const entries = generatePropertyEntries(schema, useRefImports);
   const propertyLines = entries.map((entry) => {
@@ -1956,19 +2122,19 @@ var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings
     return `    ${safeKey2(entry.key)}: ${entry.value},`;
   });
   if (!isSchemaObject3(schema) || !("patternProperties" in schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   const refPattern = patterns.find(([, ps]) => isSchemaObject3(ps) && hasRef(ps));
   if (!refPattern || !useRefImports) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   const [pattern, patternSchema] = refPattern;
   const ref = patternSchema.$ref;
   const parserName = generateParserName(refToName(ref));
   const assignmentCode = `(result as Record<string, unknown>)[key] = ${parserName}(value);`;
-  const escapedPattern = escapeRegexPattern(pattern);
+  const escapedPattern = escapeRegexPattern2(pattern);
   const inputSpread = "    ...input,";
   let objectProperties = inputSpread;
   if (propertyLines.length > 0) {
@@ -1977,9 +2143,10 @@ var generateCombinedObjectParser = (schema, typeName, useRefImports, logWarnings
 ` + line;
     }
   }
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
   return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
-    return {} as unknown as ${typeName};
+${notObjectBranch}
   }
   const result = {
 ${objectProperties}
@@ -1993,23 +2160,41 @@ ${objectProperties}
   return result;
 };`;
 };
-var generateAdditionalPropertiesParser = (schema, typeName, useRefImports) => {
+var generateAdditionalPropertiesParser = (schema, typeName, useRefImports, strict) => {
   const functionName = generateParserName(typeName);
   const additionalProps = schema.additionalProperties;
   if (!additionalProps) {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
   if (useRefImports && isSchemaObject3(additionalProps) && hasRef(additionalProps)) {
     const ref = additionalProps.$ref;
     const parserName = generateParserName(refToName(ref));
+    if (strict) {
+      return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return validateRecord(input, ${parserName}) as ${typeName};
+};`;
+    }
     return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${parserName}) as ${typeName};`;
   }
   if (isSchemaObject3(additionalProps) && hasType(additionalProps)) {
     const inlineParser = generateInlineValueParser(additionalProps);
     if (inlineParser) {
+      if (strict) {
+        return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return validateRecord(input, ${inlineParser}) as ${typeName};
+};`;
+      }
       return `export const ${functionName} = (input: unknown): ${typeName} => validateRecord(input, ${inlineParser}) as ${typeName};`;
     }
   }
+  if (strict) {
+    return `export const ${functionName} = (input: unknown): ${typeName} => {
+  if (!isObject(input)) throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);
+  return { ...input } as ${typeName};
+};`;
+  }
   return `export const ${functionName} = (input: unknown): ${typeName} => isObject(input) ? { ...input } as ${typeName} : {};`;
 };
 var generateInlineValueParser = (schema) => {
@@ -2030,18 +2215,18 @@ var generateInlineValueParser = (schema) => {
       return null;
   }
 };
-var escapeRegexPattern = (pattern) => {
+var escapeRegexPattern2 = (pattern) => {
   return pattern.replace(/\\/g, "\\\\").replace(/\//g, "\\/");
 };
-var generatePatternPropertiesParser = (schema, typeName, useRefImports) => {
+var generatePatternPropertiesParser = (schema, typeName, useRefImports, strict) => {
   const functionName = generateParserName(typeName);
   if (!("patternProperties" in schema) || typeof schema.patternProperties !== "object") {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
   const patternProps = schema.patternProperties;
   const patterns = Object.entries(patternProps);
   if (patterns.length === 0) {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
   const [pattern, patternSchema] = patterns[0];
   let patternAssignment = "(result as Record<string, unknown>)[key] = value;";
@@ -2052,10 +2237,11 @@ var generatePatternPropertiesParser = (schema, typeName, useRefImports) => {
   } else if (patternSchema === false) {
     patternAssignment = "";
   }
-  const escapedPattern = escapeRegexPattern(pattern);
+  const escapedPattern = escapeRegexPattern2(pattern);
+  const notObjectBranch = strict ? `    throw new Error(\`[${typeName}] expected object, got \${input === null ? "null" : typeof input}\`);` : `    return {} as unknown as ${typeName};`;
   return `export const ${functionName} = (input: unknown): ${typeName} => {
   if (!isObject(input)) {
-    return {} as unknown as ${typeName};
+${notObjectBranch}
   }
   const result = {
     ...input,
@@ -2167,43 +2353,44 @@ var generateSchemaObjectParser = (typeName) => {
 var selectParserStrategy = (schema, typeName, options) => {
   const useRefImports = options?.useRefImports ?? false;
   const logWarnings = options?.logWarnings ?? false;
+  const strict = options?.strict ?? false;
   if (typeName === "SchemaObject") {
     return generateSchemaObjectParser(typeName);
   }
   const isObjectLikeSchema2 = isObjectSchema2(schema) || isSchemaObject3(schema) && (("patternProperties" in schema) || ("additionalProperties" in schema));
   if (!isObjectLikeSchema2 && !isSchemaObject3(schema)) {
-    return generateNonObjectParser(typeName, schema);
+    return generateNonObjectParser(typeName, schema, strict);
   }
   if (hasProperties(schema) && isSchemaObject3(schema) && "patternProperties" in schema) {
-    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateCombinedObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   if (hasProperties(schema)) {
-    return generateObjectParser(schema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(schema, typeName, useRefImports, logWarnings, strict);
   }
   if (isSchemaObject3(schema) && "if" in schema && "then" in schema && "else" in schema) {
     return generateConditionalParser(schema, typeName);
   }
   const conditionalObjectSchema = getConditionalObjectSchema2(schema);
   if (conditionalObjectSchema) {
-    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings);
+    return generateObjectParser(conditionalObjectSchema, typeName, useRefImports, logWarnings, strict);
   }
   if (!isObjectLikeSchema2) {
-    return generateNonObjectParser(typeName, schema);
+    return generateNonObjectParser(typeName, schema, strict);
   }
   if ("patternProperties" in schema) {
-    return generatePatternPropertiesParser(schema, typeName, useRefImports);
+    return generatePatternPropertiesParser(schema, typeName, useRefImports, strict);
   }
   if ("additionalProperties" in schema && !hasProperties(schema)) {
     const additionalProps = schema.additionalProperties;
     if (additionalProps === true || additionalProps === false) {
-      return generateEmptyObjectParser(typeName);
+      return generateEmptyObjectParser(typeName, strict);
     }
-    return generateAdditionalPropertiesParser(schema, typeName, useRefImports);
+    return generateAdditionalPropertiesParser(schema, typeName, useRefImports, strict);
   }
   if ("type" in schema && schema.type === "object" && !hasProperties(schema)) {
-    return generateEmptyObjectParser(typeName);
+    return generateEmptyObjectParser(typeName, strict);
   }
-  return generateEmptyObjectParser(typeName);
+  return generateEmptyObjectParser(typeName, strict);
 };
 var generateParserFunction = (schema, typeName, options) => {
   return selectParserStrategy(schema, typeName, options);
@@ -2255,6 +2442,7 @@ var generateFile = (schema, typeName, options) => {
   const typesOnly = options?.typesOnly === true;
   const selfRef = options?.selfRef;
   const rootSchema = options?.rootSchema;
+  const helpersMode = options?.helpersMode ?? "package";
   const typeDefinition = generateTypeDefinition(schema, typeName);
   if (typesOnly) {
     const imports2 = collectImports(schema, { typesOnly: true, selfRef, rootSchema });
@@ -2269,17 +2457,19 @@ var generateFile = (schema, typeName, options) => {
 
 `;
     }
-    return result2 + typeDefinition;
+    return { content: result2 + typeDefinition, usedHelpers: new Set };
   }
   const parserFunction = generateParserFunction(schema, typeName, {
     useRefImports: true,
-    ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {}
+    ...options?.logWarnings !== undefined ? { logWarnings: options.logWarnings } : {},
+    ...options?.strict !== undefined ? { strict: options.strict } : {}
   });
   const shapeValidator = generateShapeValidator(schema, typeName, true);
   const combinedFunctions = `${shapeValidator}
 
 ${parserFunction}`;
-  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...collectHelpers(combinedFunctions)];
+  const helpers = collectHelpers(combinedFunctions, helpersMode);
+  const imports = [...collectImports(schema, { selfRef, rootSchema }), ...helpers.imports];
   let result = "";
   if (imports.length > 0) {
     result += imports[0];
@@ -2291,12 +2481,18 @@ ${parserFunction}`;
 
 `;
   }
-  return result + typeDefinition + `
+  return { content: result + typeDefinition + `
 
-` + combinedFunctions;
+` + combinedFunctions, usedHelpers: helpers.used };
 };
 
 // src/generators/build-schema.ts
+var readHelperSource = async (helper) => {
+  const require2 = createRequire(import.meta.url);
+  const helpersPkgPath = require2.resolve("@amritk/helpers/package.json");
+  const helpersRoot = dirname(helpersPkgPath);
+  return readFile(resolvePath(helpersRoot, "src", `${helper}.ts`), "utf-8");
+};
 var extractDynamicAnchorDefs = (schema) => {
   const refs = [];
   if (typeof schema !== "object" || schema === null) {
@@ -2316,26 +2512,31 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings) => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict, helpersMode = "package") => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
   const processedFilenames = new Set;
   const refsToProcess = [];
+  const usedHelpers = new Set;
   const dynamicRefMap = buildDynamicRefMap(rootSchema);
   const processedRootSchema = resolveDynamicRefs(rootSchema, dynamicRefMap);
   const extendedRootSchema = extensions ? applySchemaExtensions(processedRootSchema, rootTypeName.toLowerCase(), extensions) : processedRootSchema;
-  const rootContent = generateFile(extendedRootSchema, rootTypeName, {
+  const rootResult = generateFile(extendedRootSchema, rootTypeName, {
     typesOnly: typesOnly ?? false,
     rootSchema,
-    ...logWarnings !== undefined ? { logWarnings } : {}
+    helpersMode,
+    ...logWarnings !== undefined ? { logWarnings } : {},
+    ...strict !== undefined ? { strict } : {}
   });
   const rootFilename = rootTypeName.toLowerCase();
   processedFilenames.add(rootFilename);
   files.push({
     filename: `${rootFilename}.ts`,
-    content: rootContent
+    content: rootResult.content
   });
+  for (const helper of rootResult.usedHelpers)
+    usedHelpers.add(helper);
   const rootRefs = extractRefs(rootSchema);
   refsToProcess.push(...rootRefs);
   const dynamicAnchorRefs = extractDynamicAnchorDefs(rootSchema);
@@ -2355,19 +2556,23 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
     const filename = refToFilename(ref);
     const processedSchema = resolveDynamicRefs(resolvedSchema, dynamicRefMap);
     const extendedSchema = extensions ? applySchemaExtensions(processedSchema, filename, extensions) : processedSchema;
-    const content = generateFile(extendedSchema, typeName, {
+    const fileResult = generateFile(extendedSchema, typeName, {
       typesOnly: typesOnly ?? false,
       selfRef: ref,
       rootSchema,
-      ...logWarnings !== undefined ? { logWarnings } : {}
+      helpersMode,
+      ...logWarnings !== undefined ? { logWarnings } : {},
+      ...strict !== undefined ? { strict } : {}
     });
     if (!processedFilenames.has(filename)) {
       processedFilenames.add(filename);
       files.push({
         filename: `${filename}.ts`,
-        content
+        content: fileResult.content
       });
     }
+    for (const helper of fileResult.usedHelpers)
+      usedHelpers.add(helper);
     const nestedRefs = extractRefs(resolvedSchema);
     for (const nestedRef of nestedRefs) {
       if (!processedRefs.has(nestedRef)) {
@@ -2375,9 +2580,15 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       }
     }
   }
+  if (helpersMode === "embedded" && !typesOnly) {
+    for (const helper of usedHelpers) {
+      const source = await readHelperSource(helper);
+      files.push({ filename: `_helpers/${helper}.ts`, content: source });
+    }
+  }
   const TYPE_EXPORT_RE = /^export type (\w+)/gm;
   const CONST_EXPORT_RE = /^export const (\w+)/gm;
-  const sortedFiles = [...files].sort((a, b) => a.filename.localeCompare(b.filename));
+  const sortedFiles = [...files].filter((f) => !f.filename.startsWith("_helpers/")).sort((a, b) => a.filename.localeCompare(b.filename));
   let indexContent = "";
   for (const file of sortedFiles) {
     const moduleName = file.filename.replace(/\.ts$/, "");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -23,8 +23,12 @@
     "url": "https://github.com/amritk/mjst/issues"
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "bun run build:code && bun run build:types",
     "build:code": "bun build ./src/index.ts --outdir=dist --target=node",