ajv-formats 2.1.1: addFormats

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify addFormats in pkg:npm/ajv-formats@2.1.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/ajv-formats@2.1.1
Demonstrate these symbols/APIs:
  - addFormats

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:9fb0b1c2caa3f52c4d473076615967d2578acbb4e958efccf4630860b6da9c47","contract":["assert addFormats is a function exported by ajv-formats","assert addFormats modifies Ajv instance and returns it for chaining","assert addFormats enables email and uri format validation","assert addFormats enables date and date-time format validation","assert addFormats enables ipv4 and ipv6 format validation","assert addFormats enables uuid and int32 format validation","assert addFormats accepts an array of specific formats to selectively register","assert addFormats accepts configuration options including mode option"],"goal":"verify addFormats in pkg:npm/ajv-formats@2.1.1","kind":"HOW","packages":["pkg:npm/ajv-formats@2.1.1"],"schemaVersion":1,"symbols":["addFormats"]},"contractCommand":["node","test/contract.mjs"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"npm","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/ajv-formats@2.1.1"],"schemaVersion":1,"subject":"pkg:npm/ajv-formats@2.1.1","symbols":["addFormats"],"verifierAdapter":"node-typescript@1"}

const Ajv = require('ajv');
const addFormats = require('ajv-formats');

/**
 * Creates an Ajv instance configured with ajv-formats.
 * @param {object} [ajvOptions] - Options passed to Ajv constructor.
 * @param {string[]|object} [formatOptions] - Optional list of format names or configuration object.
 * @returns {Ajv} - Configured Ajv instance with formats applied.
 */
function createAjvWithFormats(ajvOptions = {}, formatOptions) {
  const ajv = new Ajv(ajvOptions);
  if (formatOptions) {
    addFormats(ajv, formatOptions);
  } else {
    addFormats(ajv);
  }
  return ajv;
}

/**
 * Validates data against a schema using Ajv with formats.
 * @param {object} schema - JSON schema object.
 * @param {*} data - Data to validate.
 * @param {object} [options] - Validation and format options.
 * @returns {{ valid: boolean, errors: Array|null }} - Validation result.
 */
function validateData(schema, data, options = {}) {
  const ajv = createAjvWithFormats(options.ajvOptions, options.formatOptions);
  const validate = ajv.compile(schema);
  const valid = Boolean(validate(data));
  return {
    valid,
    errors: validate.errors || null,
  };
}

module.exports = {
  addFormats,
  createAjvWithFormats,
  validateData,
};

{
  "name": "sample-ajv-formats",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-ajv-formats",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "ajv": "8.17.1",
        "ajv-formats": "2.1.1"
      }
    },
    "node_modules/ajv": {
      "version": "8.17.1",
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
      "license": "MIT",
      "dependencies": {
        "fast-deep-equal": "^3.1.3",
        "fast-uri": "^3.0.1",
        "json-schema-traverse": "^1.0.0",
        "require-from-string": "^2.0.2"
      },
      "funding": {
        "type": "github",
        "url": "https://github.com/sponsors/epoberezkin"
      }
    },
    "node_modules/ajv-formats": {
      "version": "2.1.1",
      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-2.1.1.tgz",
      "integrity": "sha512-Wx0Kx52hxE7C18hkMEggYlEifqWZtYaRgouJor+WMdPnQyEK13vgEWyVNup7SoeeoLMsr4kf5h6dOW11I15MUA==",
      "license": "MIT",
      "dependencies": {
        "ajv": "^8.0.0"
      },
      "peerDependencies": {
        "ajv": "^8.0.0"
      },
      "peerDependenciesMeta": {
        "ajv": {
          "optional": true
        }
      }
    },
    "node_modules/fast-deep-equal": {
      "version": "3.1.3",
      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
      "license": "MIT"
    },
    "node_modules/fast-uri": {
      "version": "3.1.6",
      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.6.tgz",
      "integrity": "sha512-7Ical1vFEMr0onbVzEDIreM22I4khW+fzyQPwvAFWBp1iwdshSZRsL4jjRvPG9JP1uiqMHRto+YU6R2/CzDz5Q==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/fastify"
        },
        {
          "type": "opencollective",
          "url": "https://opencollective.com/fastify"
        }
      ],
      "license": "BSD-3-Clause"
    },
    "node_modules/json-schema-traverse": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
      "license": "MIT"
    },
    "node_modules/require-from-string": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
      }
    }
  }
}

{
  "name": "sample-ajv-formats",
  "version": "1.0.0",
  "description": "Minimal clean-room sample verifying addFormats in ajv-formats",
  "main": "index.js",
  "license": "MIT-0",
  "dependencies": {
    "ajv": "8.17.1",
    "ajv-formats": "2.1.1"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify addFormats in pkg:npm/ajv-formats@2.1.1",
  "kind": "HOW",
  "packages": [
    "pkg:npm/ajv-formats@2.1.1"
  ],
  "symbols": [
    "addFormats"
  ]
}

import assert from 'node:assert/strict';
import Ajv from 'ajv';
import addFormats from 'ajv-formats';
import {
  addFormats as exportedAddFormats,
  createAjvWithFormats,
  validateData,
} from '../index.js';

// 1. assert addFormats is a function exported by ajv-formats
assert.equal(typeof addFormats, 'function', 'addFormats must be a function');
assert.equal(typeof exportedAddFormats, 'function', 'exported addFormats must be a function');

// 2. assert addFormats modifies Ajv instance and returns it for chaining
{
  const ajv = new Ajv();
  const returned = addFormats(ajv);
  assert.equal(returned, ajv, 'addFormats must return the same Ajv instance for method chaining');
  assert.equal(typeof ajv.formats['email'], 'object', 'ajv instance should have email format registered');
}

// 3. assert addFormats enables email and uri format validation
{
  const emailSchema = { type: 'string', format: 'email' };
  const uriSchema = { type: 'string', format: 'uri' };

  const validEmail = validateData(emailSchema, 'user@example.com');
  assert.equal(validEmail.valid, true, 'valid email should pass validation');

  const invalidEmail = validateData(emailSchema, 'not-a-valid-email');
  assert.equal(invalidEmail.valid, false, 'invalid email should fail validation');

  const validUri = validateData(uriSchema, 'https://example.com/api/v1/resource');
  assert.equal(validUri.valid, true, 'valid URI should pass validation');

  const invalidUri = validateData(uriSchema, '::invalid-uri::');
  assert.equal(invalidUri.valid, false, 'invalid URI should fail validation');
}

// 4. assert addFormats enables date and date-time format validation
{
  const dateSchema = { type: 'string', format: 'date' };
  const dateTimeSchema = { type: 'string', format: 'date-time' };

  assert.equal(validateData(dateSchema, '2026-08-30').valid, true, 'valid date should pass');
  assert.equal(validateData(dateSchema, '2026-13-45').valid, false, 'invalid date should fail');

  assert.equal(validateData(dateTimeSchema, '2026-08-30T20:15:00Z').valid, true, 'valid date-time should pass');
  assert.equal(validateData(dateTimeSchema, 'invalid-date-time-string').valid, false, 'invalid date-time should fail');
}

// 5. assert addFormats enables ipv4 and ipv6 format validation
{
  const ipv4Schema = { type: 'string', format: 'ipv4' };
  const ipv6Schema = { type: 'string', format: 'ipv6' };

  assert.equal(validateData(ipv4Schema, '192.168.1.1').valid, true, 'valid IPv4 should pass');
  assert.equal(validateData(ipv4Schema, '256.0.0.1').valid, false, 'invalid IPv4 should fail');

  assert.equal(validateData(ipv6Schema, '2001:0db8:85a3:0000:0000:8a2e:0370:7334').valid, true, 'valid IPv6 should pass');
  assert.equal(validateData(ipv6Schema, '2001:xyz::1').valid, false, 'invalid IPv6 should fail');
}

// 6. assert addFormats enables uuid and int32 format validation
{
  const uuidSchema = { type: 'string', format: 'uuid' };
  const int32Schema = { type: 'integer', format: 'int32' };

  assert.equal(validateData(uuidSchema, '123e4567-e89b-12d3-a456-426614174000').valid, true, 'valid UUID should pass');
  assert.equal(validateData(uuidSchema, 'not-a-uuid-string').valid, false, 'invalid UUID should fail');

  assert.equal(validateData(int32Schema, 2147483647).valid, true, 'max int32 should pass');
  assert.equal(validateData(int32Schema, 2147483648).valid, false, 'out-of-range int32 should fail');
}

// 7. assert addFormats accepts an array of specific formats to selectively register
{
  const ajv = createAjvWithFormats({}, ['email', 'date']);
  assert.ok(ajv.formats['email'], 'email format should be present');
  assert.ok(ajv.formats['date'], 'date format should be present');
  assert.equal(ajv.formats['ipv4'], undefined, 'ipv4 format should not be registered when omitted from list');
}

// 8. assert addFormats accepts configuration options including mode option
{
  const ajvFast = createAjvWithFormats({}, { mode: 'fast', formats: ['date-time'] });
  assert.ok(ajvFast.formats['date-time'], 'date-time format should be registered with fast mode');
  assert.equal(ajvFast.formats['email'], undefined, 'email format should not be registered when omitted');
}

console.log('All addFormats contract assertions passed.');