@amritk/generate-validators 0.2.3 → 0.3.1

package/dist/index.js

@@ -351,6 +351,31 @@ var isSchemaObject2 = (schema) => {
 var isObjectSchema = (schema) => {
   return isSchemaObject2(schema) && (("type" in schema) && schema.type === "object" || ("properties" in schema));
 };
+var MJST_EXTENSION_KEY = "x-mjst";
+var IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SUPPORTED_PRIMITIVES = new Set(["bigint"]);
+var SAFE_BRAND = /^[\w$ -]+$/;
+var readExtensionString = (schema, field) => {
+  if (!isSchemaObject2(schema))
+    return;
+  const extension = schema[MJST_EXTENSION_KEY];
+  if (typeof extension !== "object" || extension === null)
+    return;
+  const value = extension[field];
+  return typeof value === "string" ? value : undefined;
+};
+var getMjstInstanceOf = (schema) => {
+  const instanceOf = readExtensionString(schema, "instanceOf");
+  return instanceOf !== undefined && IDENTIFIER.test(instanceOf) ? instanceOf : undefined;
+};
+var getMjstPrimitive = (schema) => {
+  const primitive = readExtensionString(schema, "primitive");
+  return primitive !== undefined && SUPPORTED_PRIMITIVES.has(primitive) ? primitive : undefined;
+};
+var getMjstBrand = (schema) => {
+  const brand = readExtensionString(schema, "brand");
+  return brand !== undefined && SAFE_BRAND.test(brand) ? brand : undefined;
+};
 var toKebabCase4 = (value) => value.replace(/OAuth/g, "Oauth").replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
 var uriRefToFilename4 = (uri) => {
   const hashIndex = uri.indexOf("#");
@@ -491,13 +516,27 @@ var buildJsDocBlock = (title, description, commentUrl) => {
 `;
   return block;
 };
-var getTypeScriptType = (schema) => {
+var getTypeScriptType = (schema, options = {}) => {
+  const base = getUnbrandedType(schema, options);
+  const brand = getMjstBrand(schema);
+  return brand ? `(${base} & { readonly __brand: '${brand}' })` : base;
+};
+var recordType = (keyType, valueType, options) => options.readonly ? `Readonly<Record<${keyType}, ${valueType}>>` : `Record<${keyType}, ${valueType}>`;
+var getUnbrandedType = (schema, options = {}) => {
   if (typeof schema === "boolean") {
     return getBooleanSubSchemaType(schema);
   }
   if (typeof schema !== "object" || schema === null) {
     return "unknown";
   }
+  const instanceOf = getMjstInstanceOf(schema);
+  if (instanceOf) {
+    return instanceOf;
+  }
+  const primitive = getMjstPrimitive(schema);
+  if (primitive) {
+    return primitive;
+  }
   if (schema.$ref) {
     if (!schema.$ref.startsWith("#")) {
       return "unknown";
@@ -531,29 +570,29 @@ var getTypeScriptType = (schema) => {
     return multiEnumUnion;
   }
   if (schema.oneOf && Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
-    let oneOfUnion = getTypeScriptType(schema.oneOf[0]);
+    let oneOfUnion = getTypeScriptType(schema.oneOf[0], options);
     for (let i = 1;i < schema.oneOf.length; i++) {
-      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i]);
+      oneOfUnion += " | " + getTypeScriptType(schema.oneOf[i], options);
     }
     return oneOfUnion;
   }
   if (schema.anyOf && Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
-    let anyOfUnion = getTypeScriptType(schema.anyOf[0]);
+    let anyOfUnion = getTypeScriptType(schema.anyOf[0], options);
     for (let i = 1;i < schema.anyOf.length; i++) {
-      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i]);
+      anyOfUnion += " | " + getTypeScriptType(schema.anyOf[i], options);
     }
     return anyOfUnion;
   }
   if (schema.allOf && Array.isArray(schema.allOf) && schema.allOf.length > 0) {
-    let intersectionTypes = getTypeScriptType(schema.allOf[0]);
+    let intersectionTypes = getTypeScriptType(schema.allOf[0], options);
     for (let i = 1;i < schema.allOf.length; i++) {
-      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i]);
+      intersectionTypes += " & " + getTypeScriptType(schema.allOf[i], options);
     }
     return intersectionTypes;
   }
   const conditionalResult = getConditionalObjectSchema(schema);
   if (conditionalResult) {
-    const baseType = getTypeScriptType(conditionalResult.schema);
+    const baseType = getTypeScriptType(conditionalResult.schema, options);
     if (conditionalResult.thenRef) {
       return `(${baseType}) & ${refToName2(conditionalResult.thenRef)}`;
     }
@@ -562,20 +601,20 @@ var getTypeScriptType = (schema) => {
   if (!schema.type) {
     if (schema.additionalProperties !== undefined) {
       if (typeof schema.additionalProperties === "boolean") {
-        return `Record<string, ${getBooleanSubSchemaType(schema.additionalProperties)}>`;
+        return recordType("string", getBooleanSubSchemaType(schema.additionalProperties), options);
       }
-      return `Record<string, ${getTypeScriptType(schema.additionalProperties)}>`;
+      return recordType("string", getTypeScriptType(schema.additionalProperties, options), options);
     }
     if (schema.patternProperties && typeof schema.patternProperties === "object") {
       const firstEntry = Object.entries(schema.patternProperties)[0];
       if (firstEntry) {
         const [pattern, value] = firstEntry;
         if (value !== undefined) {
-          const valueType = typeof value === "boolean" ? getBooleanSubSchemaType(value) : getTypeScriptType(value);
+          const valueType = typeof value === "boolean" ? getBooleanSubSchemaType(value) : getTypeScriptType(value, options);
           if (pattern === "^x-") {
-            return `Record<\`x-\${string}\`, ${valueType}>`;
+            return recordType("`x-${string}`", valueType, options);
           }
-          return `Record<string, ${valueType}>`;
+          return recordType("string", valueType, options);
         }
       }
     }
@@ -628,41 +667,42 @@ var getTypeScriptType = (schema) => {
       return "boolean";
     case "array":
       if (schema.items) {
-        const itemType = getTypeScriptType(schema.items);
+        const itemType = getTypeScriptType(schema.items, options);
         const wrappedItemType = itemType.includes(" | ") ? `(${itemType})` : itemType;
-        return `${wrappedItemType}[]`;
+        return options.readonly ? `readonly ${wrappedItemType}[]` : `${wrappedItemType}[]`;
       }
-      return "unknown[]";
+      return options.readonly ? "readonly unknown[]" : "unknown[]";
     case "object":
       if (schema.properties) {
+        const readonlyPrefix = options.readonly ? "readonly " : "";
         let properties = "";
         let first = true;
         for (const key in schema.properties) {
           const propSchema = schema.properties[key];
           const isRequired = schema.required?.includes(key) ?? false;
           const optional = isRequired ? "" : "?";
-          const propType = getTypeScriptType(propSchema);
+          const propType = getTypeScriptType(propSchema, options);
           if (!first)
             properties += "; ";
-          properties += safeKey(key) + optional + ": " + propType;
+          properties += readonlyPrefix + safeKey(key) + optional + ": " + propType;
           first = false;
         }
         return "{ " + properties + " }";
       }
       if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
-        const additionalPropType = getTypeScriptType(schema.additionalProperties);
-        return `Record<string, ${additionalPropType}>`;
+        const additionalPropType = getTypeScriptType(schema.additionalProperties, options);
+        return recordType("string", additionalPropType, options);
       }
       if (schema.patternProperties && typeof schema.patternProperties === "object") {
         const firstEntry = Object.entries(schema.patternProperties)[0];
         if (firstEntry) {
           const [pattern, patternVal] = firstEntry;
           if (patternVal) {
-            const valueType = getTypeScriptType(patternVal);
+            const valueType = getTypeScriptType(patternVal, options);
             if (pattern === "^x-") {
-              return `Record<\`x-\${string}\`, ${valueType}>`;
+              return recordType("`x-${string}`", valueType, options);
             }
-            return `Record<string, ${valueType}>`;
+            return recordType("string", valueType, options);
           }
         }
       }
@@ -671,9 +711,10 @@ var getTypeScriptType = (schema) => {
       return "unknown";
   }
 };
-var generateTypeDefinition = (schema, typeName) => {
+var generateTypeDefinition = (schema, typeName, options = {}) => {
+  const readonlyPrefix = options.readonly ? "readonly " : "";
   if (!isObjectLikeSchema(schema)) {
-    const tsType = getTypeScriptType(schema);
+    const tsType = getTypeScriptType(schema, options);
     let result = "";
     if (isSchemaObject2(schema) && schema.$comment && typeof schema.$comment === "string") {
       result += buildJsDocBlock(typeName, schema.$comment);
@@ -701,23 +742,23 @@ var generateTypeDefinition = (schema, typeName) => {
       if (firstPatternProperty === undefined) {
         return `export type ${typeName} = Record<string, unknown>;`;
       }
-      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty);
+      const patternPropType = typeof firstPatternProperty === "boolean" ? getBooleanSubSchemaType(firstPatternProperty) : getTypeScriptType(firstPatternProperty, options);
       const keyType = firstPattern === "^x-" ? "`x-${string}`" : "string";
       let result2 = "";
       if (jsDocTitle && jsDocDescription) {
         result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
       }
-      result2 += `export type ${typeName} = Record<${keyType}, ${patternPropType}>;`;
+      result2 += `export type ${typeName} = ${recordType(keyType, patternPropType, options)};`;
       return result2;
     }
     if (!hasProperties2 && hasAdditionalProperties2 && normalizedSchema.additionalProperties) {
-      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties);
+      const additionalPropType = getTypeScriptType(normalizedSchema.additionalProperties, options);
       let result2 = "";
       if (jsDocTitle && jsDocDescription) {
         result2 += buildJsDocBlock(jsDocTitle, jsDocDescription);
       }
       result2 += `export type ${typeName} = {
-  [key: string]: ${additionalPropType};
+  ${readonlyPrefix}[key: string]: ${additionalPropType};
 };`;
       return result2;
     }
@@ -728,8 +769,8 @@ var generateTypeDefinition = (schema, typeName) => {
       const propSchema = schemaProps[key];
       const isRequired = normalizedSchema.required?.includes(key) ?? false;
       const optional = isRequired ? "" : "?";
-      const propType = getTypeScriptType(propSchema);
-      const quotedKey = safeKey(key);
+      const propType = getTypeScriptType(propSchema, options);
+      const quotedKey = readonlyPrefix + safeKey(key);
       if (!isFirstProp)
         properties += `
 `;
@@ -903,6 +944,31 @@ var collectValidatorImports = (schema, options) => {
   return imports;
 };
 
+// ../helpers/dist/mjst-extension.js
+var isSchemaObject4 = (schema) => {
+  return typeof schema === "object" && schema !== null && typeof schema !== "boolean";
+};
+var MJST_EXTENSION_KEY2 = "x-mjst";
+var IDENTIFIER2 = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var SUPPORTED_PRIMITIVES2 = new Set(["bigint"]);
+var readExtensionString2 = (schema, field) => {
+  if (!isSchemaObject4(schema))
+    return;
+  const extension = schema[MJST_EXTENSION_KEY2];
+  if (typeof extension !== "object" || extension === null)
+    return;
+  const value = extension[field];
+  return typeof value === "string" ? value : undefined;
+};
+var getMjstInstanceOf2 = (schema) => {
+  const instanceOf = readExtensionString2(schema, "instanceOf");
+  return instanceOf !== undefined && IDENTIFIER2.test(instanceOf) ? instanceOf : undefined;
+};
+var getMjstPrimitive2 = (schema) => {
+  const primitive = readExtensionString2(schema, "primitive");
+  return primitive !== undefined && SUPPORTED_PRIMITIVES2.has(primitive) ? primitive : undefined;
+};
+
 // src/generators/generate-validator-function.ts
 var validatorName = (typeName) => `validate${typeName}`;
 var typeofString = (type) => {
@@ -951,6 +1017,36 @@ var generatePropertyChecks = (key, propSchema, isRequired) => {
     }
     return lines;
   }
+  const instanceOf = getMjstInstanceOf2(propSchema);
+  if (instanceOf) {
+    if (isRequired) {
+      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+      lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`);
+      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+      lines.push(`  }`);
+    } else {
+      lines.push(`  if (${raw} !== undefined && !(${raw} instanceof ${instanceOf})) {`);
+      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`);
+      lines.push(`  }`);
+    }
+    return lines;
+  }
+  const primitive = getMjstPrimitive2(propSchema);
+  if (primitive) {
+    if (isRequired) {
+      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`);
+      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`);
+      lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`);
+      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
+      lines.push(`  }`);
+    } else {
+      lines.push(`  if (${raw} !== undefined && typeof ${raw} !== "${primitive}") {`);
+      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`);
+      lines.push(`  }`);
+    }
+    return lines;
+  }
   if (hasEnum(propSchema)) {
     const allowed = JSON.stringify(propSchema.enum);
     const label = propSchema.enum.map((v) => JSON.stringify(v)).join(", ");
@@ -1105,6 +1201,30 @@ var generateScalarValidator = (schema, typeName) => {
       `  return ${delegateName}(input, _path)`,
       `}`
     ].join(`
+`);
+  }
+  const instanceOf = getMjstInstanceOf2(schema);
+  if (instanceOf) {
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (!(input instanceof ${instanceOf})) {`,
+      `    return { valid: false, errors: [{ message: 'must be ${instanceOf}', path: _path }] }`,
+      `  }`,
+      `  return true`,
+      `}`
+    ].join(`
+`);
+  }
+  const primitive = getMjstPrimitive2(schema);
+  if (primitive) {
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (typeof input !== "${primitive}") {`,
+      `    return { valid: false, errors: [{ message: 'must be ${primitive}', path: _path }] }`,
+      `  }`,
+      `  return true`,
+      `}`
+    ].join(`
 `);
   }
   if (hasEnum(schema)) {
@@ -1145,34 +1265,50 @@ var generateScalarValidator = (schema, typeName) => {
     if (t === "string") {
       if (hasPattern(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`);
-        constraintLines.push(`    return { valid: false, errors: [{ message: 'must match pattern ${schema.pattern}', path: _path }] }`);
+        constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`);
         constraintLines.push(`  }`);
       }
       if (hasMinLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`);
-        constraintLines.push(`    return { valid: false, errors: [{ message: 'must have at least ${schema.minLength} characters', path: _path }] }`);
+        constraintLines.push(`    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`);
         constraintLines.push(`  }`);
       }
       if (hasMaxLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`);
-        constraintLines.push(`    return { valid: false, errors: [{ message: 'must have at most ${schema.maxLength} characters', path: _path }] }`);
+        constraintLines.push(`    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`);
         constraintLines.push(`  }`);
       }
     }
-    const body = constraintLines.length > 0 ? `
-` + constraintLines.join(`
-`) + `
-` : "";
-    return wrongType ? [
+    if (!wrongType) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return true`,
+        `}`
+      ].join(`
+`);
+    }
+    if (constraintLines.length === 0) {
+      return [
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  if (${wrongType}) {`,
+        `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+        `  }`,
+        `  return true`,
+        `}`
+      ].join(`
+`);
+    }
+    return [
       `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
       `  if (${wrongType}) {`,
       `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
       `  }`,
-      body,
-      `  return true`,
+      `  const errors: ValidationError[] = []`,
+      constraintLines.join(`
+`),
+      `  return errors.length > 0 ? { valid: false, errors } : true`,
       `}`
     ].join(`
-`) : [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`
 `);
   }
   return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Generate TypeScript validation functions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -46,8 +46,8 @@
     }
   },
   "dependencies": {
-    "json-schema-typed": "catalog:",
-    "@amritk/helpers": "workspace:*"
+    "json-schema-typed": "^8.0.1",
+    "@amritk/helpers": "0.5.0"
   },
   "devDependencies": {
     "@scalar/openapi-parser": "^0.26.1"

package/src/generators/generate-validator-function.test.ts

@@ -147,6 +147,18 @@ describe('generate-validator-function', () => {
     expect(code).toContain('must be string')
   })
 
+  it('accumulates all constraint errors for a scalar string schema', () => {
+    const schema = { type: 'string' as const, pattern: '^\\d+$', minLength: 2, maxLength: 4 }
+    const code = generateValidatorFunction(schema, 'Code')
+
+    // All three constraints push onto a shared errors array instead of returning early
+    expect(code).toContain('const errors: ValidationError[] = []')
+    expect(code).toContain("errors.push({ message: 'must match pattern")
+    expect(code).toContain("errors.push({ message: 'must have at least 2 characters'")
+    expect(code).toContain("errors.push({ message: 'must have at most 4 characters'")
+    expect(code).toContain('return errors.length > 0 ? { valid: false, errors } : true')
+  })
+
   it('returns true for empty object schemas', () => {
     const schema = { type: 'object' as const }
     const code = generateValidatorFunction(schema, 'Empty')
@@ -164,4 +176,63 @@ describe('generate-validator-function', () => {
     expect(code).toContain('Array.isArray(input)')
     expect(code).toContain('must be object')
   })
+
+  it('generates an instanceof check for a required x-mjst Date property', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { createdAt: { 'x-mjst': { instanceOf: 'Date' } } },
+      required: ['createdAt'],
+    }
+    const code = generateValidatorFunction(schema, 'Event')
+
+    expect(code).toContain('"createdAt" in obj')
+    expect(code).toContain('!(obj["createdAt"] instanceof Date)')
+    expect(code).toContain('must be Date')
+  })
+
+  it('generates an instanceof check for an optional x-mjst Date property', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { createdAt: { 'x-mjst': { instanceOf: 'Date' } } },
+    }
+    const code = generateValidatorFunction(schema, 'Event')
+
+    expect(code).toContain('obj["createdAt"] !== undefined && !(obj["createdAt"] instanceof Date)')
+  })
+
+  it('generates an instanceof check for a top-level x-mjst Date schema', () => {
+    const code = generateValidatorFunction({ 'x-mjst': { instanceOf: 'Date' } }, 'When')
+
+    expect(code).toContain('!(input instanceof Date)')
+    expect(code).toContain('must be Date')
+  })
+
+  it('generates a typeof check for a required x-mjst bigint property', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { balance: { 'x-mjst': { primitive: 'bigint' } } },
+      required: ['balance'],
+    }
+    const code = generateValidatorFunction(schema, 'Account')
+
+    expect(code).toContain('typeof obj["balance"] !== "bigint"')
+    expect(code).toContain('must be bigint')
+  })
+
+  it('guards undefined for an optional x-mjst bigint property', () => {
+    const schema = {
+      type: 'object' as const,
+      properties: { balance: { 'x-mjst': { primitive: 'bigint' } } },
+    }
+    const code = generateValidatorFunction(schema, 'Account')
+
+    expect(code).toContain('obj["balance"] !== undefined && typeof obj["balance"] !== "bigint"')
+  })
+
+  it('generates a typeof check for a top-level x-mjst bigint schema', () => {
+    const code = generateValidatorFunction({ 'x-mjst': { primitive: 'bigint' } }, 'Big')
+
+    expect(code).toContain('typeof input !== "bigint"')
+    expect(code).toContain('must be bigint')
+  })
 })

package/src/generators/generate-validator-function.ts

@@ -1,3 +1,4 @@
+import { getMjstInstanceOf, getMjstPrimitive } from '@amritk/helpers/mjst-extension'
 import { refToName } from '@amritk/helpers/ref-to-name'
 import {
   hasAdditionalProperties,
@@ -88,6 +89,40 @@ const generatePropertyChecks = (key: string, propSchema: JSONSchema, isRequired:
     return lines
   }
 
+  // x-mjst instanceOf (e.g. Date) — value must be an instance of the class
+  const instanceOf = getMjstInstanceOf(propSchema)
+  if (instanceOf) {
+    if (isRequired) {
+      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`)
+      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`)
+      lines.push(`  } else if (!(${raw} instanceof ${instanceOf})) {`)
+      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`)
+      lines.push(`  }`)
+    } else {
+      lines.push(`  if (${raw} !== undefined && !(${raw} instanceof ${instanceOf})) {`)
+      lines.push(`    errors.push({ message: 'must be ${instanceOf}', path: ${path} })`)
+      lines.push(`  }`)
+    }
+    return lines
+  }
+
+  // x-mjst primitive (e.g. bigint) — value must satisfy a typeof check
+  const primitive = getMjstPrimitive(propSchema)
+  if (primitive) {
+    if (isRequired) {
+      lines.push(`  if (!(${JSON.stringify(key)} in obj)) {`)
+      lines.push(`    errors.push({ message: "must have required property '${key}'", path: _path })`)
+      lines.push(`  } else if (typeof ${raw} !== "${primitive}") {`)
+      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`)
+      lines.push(`  }`)
+    } else {
+      lines.push(`  if (${raw} !== undefined && typeof ${raw} !== "${primitive}") {`)
+      lines.push(`    errors.push({ message: 'must be ${primitive}', path: ${path} })`)
+      lines.push(`  }`)
+    }
+    return lines
+  }
+
   // enum
   if (hasEnum(propSchema)) {
     const allowed = JSON.stringify(propSchema.enum)
@@ -281,6 +316,32 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
     ].join('\n')
   }
 
+  // Top-level x-mjst instanceOf (e.g. a schema that is itself a Date)
+  const instanceOf = getMjstInstanceOf(schema)
+  if (instanceOf) {
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (!(input instanceof ${instanceOf})) {`,
+      `    return { valid: false, errors: [{ message: 'must be ${instanceOf}', path: _path }] }`,
+      `  }`,
+      `  return true`,
+      `}`,
+    ].join('\n')
+  }
+
+  // Top-level x-mjst primitive (e.g. a schema that is itself a bigint)
+  const primitive = getMjstPrimitive(schema)
+  if (primitive) {
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (typeof input !== "${primitive}") {`,
+      `    return { valid: false, errors: [{ message: 'must be ${primitive}', path: _path }] }`,
+      `  }`,
+      `  return true`,
+      `}`,
+    ].join('\n')
+  }
+
   // Top-level enum
   if (hasEnum(schema)) {
     const allowed = JSON.stringify(schema.enum)
@@ -325,42 +386,54 @@ const generateScalarValidator = (schema: JSONSchema, typeName: string): string =
     if (t === 'string') {
       if (hasPattern(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && !/${schema.pattern}/.test(input)) {`)
-        constraintLines.push(
-          `    return { valid: false, errors: [{ message: 'must match pattern ${schema.pattern}', path: _path }] }`,
-        )
+        constraintLines.push(`    errors.push({ message: 'must match pattern ${schema.pattern}', path: _path })`)
         constraintLines.push(`  }`)
       }
       if (hasMinLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length < ${schema.minLength}) {`)
         constraintLines.push(
-          `    return { valid: false, errors: [{ message: 'must have at least ${schema.minLength} characters', path: _path }] }`,
+          `    errors.push({ message: 'must have at least ${schema.minLength} characters', path: _path })`,
         )
         constraintLines.push(`  }`)
       }
       if (hasMaxLength(schema)) {
         constraintLines.push(`  if (typeof input === 'string' && input.length > ${schema.maxLength}) {`)
         constraintLines.push(
-          `    return { valid: false, errors: [{ message: 'must have at most ${schema.maxLength} characters', path: _path }] }`,
+          `    errors.push({ message: 'must have at most ${schema.maxLength} characters', path: _path })`,
         )
         constraintLines.push(`  }`)
       }
     }
 
-    const body = constraintLines.length > 0 ? '\n' + constraintLines.join('\n') + '\n' : ''
-
-    return wrongType
-      ? [
-          `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
-          `  if (${wrongType}) {`,
-          `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
-          `  }`,
-          body,
-          `  return true`,
-          `}`,
-        ].join('\n')
-      : [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(
-          '\n',
-        )
+    if (!wrongType) {
+      return [
+        `export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`,
+        `  return true`,
+        `}`,
+      ].join('\n')
+    }
+
+    if (constraintLines.length === 0) {
+      return [
+        `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+        `  if (${wrongType}) {`,
+        `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+        `  }`,
+        `  return true`,
+        `}`,
+      ].join('\n')
+    }
+
+    return [
+      `export const ${vName} = (input: unknown, _path = ''): ValidationResult => {`,
+      `  if (${wrongType}) {`,
+      `    return { valid: false, errors: [{ message: 'must be ${typLabel}', path: _path }] }`,
+      `  }`,
+      `  const errors: ValidationError[] = []`,
+      constraintLines.join('\n'),
+      `  return errors.length > 0 ? { valid: false, errors } : true`,
+      `}`,
+    ].join('\n')
   }
 
   return [`export const ${vName} = (_input: unknown, _path = ''): ValidationResult => {`, `  return true`, `}`].join(