@amritk/generate-parsers 0.1.0 → 0.2.1

package/README.md

@@ -75,7 +75,7 @@ Write them to disk however you like.
 
 ## API
 
-### `buildSchema(rootSchema, rootTypeName, extensions?, typesOnly?, logWarnings?)`
+### `buildSchema(rootSchema, rootTypeName, extensions?, typesOnly?, logWarnings?, strict?)`
 
 | Parameter | Type | Description |
 |:---|:---|:---|
@@ -84,6 +84,7 @@ Write them to disk however you like.
 | `extensions` | `SchemaExtensions` _(optional)_ | Map of definition name → extra optional properties to merge in before generation. |
 | `typesOnly` | `boolean` _(optional)_ | When `true`, only emit `.ts` type definitions — skip parser functions and runtime helpers. |
 | `logWarnings` | `boolean` _(optional)_ | When `true`, generated parsers emit a `console.warn` for every input key not declared in the schema's properties. |
+| `strict` | `boolean` _(optional)_ | When `true`, generated parsers throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. |
 
 Returns: `Promise<GeneratedFile[]>`.
 
@@ -96,6 +97,7 @@ Returns: `Promise<GeneratedFile[]>`.
 |:---:|:---|:---|:---:|:---:|:---:|:---|
 | 🏷️ | `typesOnly` | — | `boolean` | — | `false` | Generate only TypeScript type definitions without parser functions. Runtime helper files (validators, isObject) are also omitted since they are only needed for parsers. |
 | ⚠️ | `logWarnings` | — | `boolean` | — | `false` | Emit a console.warn in the generated parsers for every input key that is not declared in the schema's properties. Useful for detecting schema drift or unexpected data shapes at runtime. |
+| 🚫 | `strict` | — | `boolean` | — | `false` | Generate parsers that throw on type/shape mismatches (wrong type, missing required property, enum/pattern/min/max violations) instead of coercing invalid input to default values. Unknown extra keys are still allowed. |
 <!-- config-table-end -->
 
 The generator handles:

package/dist/generators/build-schema.d.ts

@@ -27,6 +27,9 @@ export type GeneratedFile = {
  * @param typesOnly - When true, only generate TypeScript type definitions without parser functions.
  * @param logWarnings - When true, the generated parsers emit a console.warn for every input key
  *   that is not declared in the schema's properties.
+ * @param strict - When true, the generated parsers throw on type/shape mismatches
+ *   (wrong type, missing required property, enum/pattern/min/max violations) instead
+ *   of coercing invalid input to default values.
  * @returns An array of generated TypeScript files
  *
  * @example
@@ -59,4 +62,4 @@ export type GeneratedFile = {
  * });
  * ```
  */
-export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean) => Promise<GeneratedFile[]>;
+export declare const buildSchema: (rootSchema: JSONSchema, rootTypeName: string, extensions?: SchemaExtensions, typesOnly?: boolean, logWarnings?: boolean, strict?: boolean) => Promise<GeneratedFile[]>;

package/dist/generators/generate-files.d.ts

@@ -24,6 +24,11 @@ type GenerateFileOptions = {
      * that is not declared in the schema's properties.
      */
     readonly logWarnings?: boolean;
+    /**
+     * When true, the generated parser throws on type/shape mismatches instead
+     * of coercing invalid input to default values.
+     */
+    readonly strict?: boolean;
 };
 /**
  * Generates a complete TypeScript file from a JSON Schema.

package/dist/generators/generate-parser-function.d.ts

@@ -14,6 +14,12 @@ type GenerateParserOptions = {
      * that is not declared in the schema's properties.
      */
     readonly logWarnings?: boolean;
+    /**
+     * When true, the generated parser throws on type/shape mismatches instead
+     * of coercing invalid input to default values. Throws on the first violation
+     * with a path-aware Error. Unknown extra keys are still allowed.
+     */
+    readonly strict?: boolean;
 };
 /**
  * Generates a safe parser as an arrow function that never throws.

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

@@ -0,0 +1,18 @@
+import type { JSONSchema } from 'json-schema-typed/draft-2020-12';
+/**
+ * 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.
+ */
+export declare const generateObjectStrictAssertion: (schema: JSONSchema, typeName: string) => 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.
+ */
+export declare const generateScalarStrictAssertion: (schema: JSONSchema, typeName: string) => string | null;

package/dist/index.js

@@ -1142,6 +1142,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 +1825,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 +1855,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 +1891,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 +1944,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 +2088,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 +2098,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 +2119,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 +2136,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 +2191,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 +2213,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 +2329,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);
@@ -2273,7 +2436,8 @@ var generateFile = (schema, typeName, options) => {
   }
   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}
@@ -2316,7 +2480,7 @@ var extractDynamicAnchorDefs = (schema) => {
   }
   return refs;
 };
-var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings) => {
+var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWarnings, strict) => {
   rootSchema = upgradeDraft07Schema(rootSchema);
   const files = [];
   const processedRefs = new Set;
@@ -2328,7 +2492,8 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
   const rootContent = generateFile(extendedRootSchema, rootTypeName, {
     typesOnly: typesOnly ?? false,
     rootSchema,
-    ...logWarnings !== undefined ? { logWarnings } : {}
+    ...logWarnings !== undefined ? { logWarnings } : {},
+    ...strict !== undefined ? { strict } : {}
   });
   const rootFilename = rootTypeName.toLowerCase();
   processedFilenames.add(rootFilename);
@@ -2359,7 +2524,8 @@ var buildSchema = async (rootSchema, rootTypeName, extensions, typesOnly, logWar
       typesOnly: typesOnly ?? false,
       selfRef: ref,
       rootSchema,
-      ...logWarnings !== undefined ? { logWarnings } : {}
+      ...logWarnings !== undefined ? { logWarnings } : {},
+      ...strict !== undefined ? { strict } : {}
     });
     if (!processedFilenames.has(filename)) {
       processedFilenames.add(filename);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -25,6 +25,9 @@
   "files": [
     "dist"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "bun run build:code && bun run build:types",
     "build:code": "bun build ./src/index.ts --outdir=dist --target=node",