@amritk/generate-validators 0.2.2 → 0.3.0

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("#");
@@ -492,12 +517,25 @@ var buildJsDocBlock = (title, description, commentUrl) => {
   return block;
 };
 var getTypeScriptType = (schema) => {
+  const base = getUnbrandedType(schema);
+  const brand = getMjstBrand(schema);
+  return brand ? `(${base} & { readonly __brand: '${brand}' })` : base;
+};
+var getUnbrandedType = (schema) => {
   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";
@@ -903,6 +941,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 +1014,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 +1198,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)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-validators",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "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.4.0"
   },
   "devDependencies": {
     "@scalar/openapi-parser": "^0.26.1"

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

@@ -164,4 +164,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)