21777411725

Committed 07 Feb 2026 08:46AM UTC coverage: 91.269% (+0.4%) from 90.868%

Build # 21777411725

Build Type

Pull #336

github

Committed by

web-flow

Commit Message

Merge 8aec8e8f7 into 87b824610

Pull Request Pull Request #336: feat!: new api, see docs for changes

Run Details

480 of 491 branches covered (97.76%)

Branch coverage included in aggregate %.

110 of 136 new or added lines in 5 files covered. (80.88%)

1 existing line in 1 file now uncovered.

1412 of 1582 relevant lines covered (89.25%)

24576.11 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.13

/src/format-validators.ts

import isEmailModule from 'validator/lib/isEmail.js';
import isIPModule from 'validator/lib/isIP.js';
import isURLModule from 'validator/lib/isURL.js';
import { sortedKeys } from './utils/json.js';

export type FormatValidatorFn = (input: unknown) => boolean | Promise<boolean>;

const dateValidator: FormatValidatorFn = (date: unknown) => {
  if (typeof date !== 'string') {
    return true;
  }
  // full-date from http://tools.ietf.org/html/rfc3339#section-5.6
  const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);
  if (matches === null) {
    return false;
  }
  // var year = matches[1];
  // var month = matches[2];
  // var day = matches[3];
  if (matches[2] < '01' || matches[2] > '12' || matches[3] < '01' || matches[3] > '31') {
    return false;
  }
  return true;
};

const dateTimeValidator: FormatValidatorFn = (dateTime: unknown) => {
  if (typeof dateTime !== 'string') {
    return true;
  }
  // date-time from http://tools.ietf.org/html/rfc3339#section-5.6
  const s = dateTime.toLowerCase().split('t');
  if (s.length !== 2) {
    return false;
  }
  const datePart = s[0];
  const timePart = s[1];
  // Check date
  const dateMatches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(datePart);
  if (dateMatches === null) {
    return false;
  }
  const year = parseInt(dateMatches[1], 10);
  const month = parseInt(dateMatches[2], 10);
  const day = parseInt(dateMatches[3], 10);
  if (month < 1 || month > 12 || day < 1 || day > 31) {
    return false;
  }
  // Check if date is valid
  const date = new Date(year, month - 1, day);
  if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day) {
    return false;
  }
  // Check time
  const timeMatches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z|([+-][0-9]{2}:[0-9]{2}))$/.exec(timePart);
  if (timeMatches === null) {
    return false;
  }
  const hour = parseInt(timeMatches[1], 10);
  const minute = parseInt(timeMatches[2], 10);
  const second = parseInt(timeMatches[3], 10);
  if (hour > 23 || minute > 59 || second > 60) {
    return false;
  }
  // Check offset
  let utcHour = hour;
  if (timeMatches[5] !== 'z') {
    const offset = timeMatches[5];
    const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(offset);
    if (offsetMatches === null) {
      return false;
    }
    const offsetSign = offsetMatches[1];
    const offsetHour = parseInt(offsetMatches[2], 10);
    const offsetMinute = parseInt(offsetMatches[3], 10);
    if (offsetHour > 23 || offsetMinute > 59) {
      return false;
    }
    if (offsetSign === '+') {
      utcHour = hour - offsetHour;
    } else {
      utcHour = hour + offsetHour;
    }
    utcHour = ((utcHour % 24) + 24) % 24;
  }
  // Leap second only at 23:59:60 UTC
  if (second === 60) {
    if (utcHour !== 23 || minute !== 59) {
      return false;
    }
  }
  return true;
};

const emailValidator: FormatValidatorFn = (email: unknown) => {
  if (typeof email !== 'string') {
    return true;
  }
  return isEmailModule.default(email, { require_tld: true });
};

const hostnameValidator: FormatValidatorFn = (hostname: unknown) => {
  if (typeof hostname !== 'string') {
    return true;
  }
  /*
          http://json-schema.org/latest/json-schema-validation.html#anchor114
          A string instance is valid against this attribute if it is a valid
          representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].

          http://tools.ietf.org/html/rfc1034#section-3.5

          <digit> ::= any one of the ten digits 0 through 9
          var digit = /[0-9]/;

          <letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
          var letter = /[a-zA-Z]/;

          <let-dig> ::= <letter> | <digit>
          var letDig = /[0-9a-zA-Z]/;

          <let-dig-hyp> ::= <let-dig> | "-"
          var letDigHyp = /[-0-9a-zA-Z]/;

          <ldh-str> ::= <let-dig-hyp> | <let-dig-hyp> <ldh-str>
          var ldhStr = /[-0-9a-zA-Z]+/;

          <label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
          var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;

          <subdomain> ::= <label> | <subdomain> "." <label>
          var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;

          <domain> ::= <subdomain> | " "
          var domain = null;
      */
  const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);
  if (valid) {
    // the sum of all label octets and label lengths is limited to 255.
    if (hostname.length > 255) {
      return false;
    }
    // Each node has a label, which is zero to 63 octets in length
    const labels = hostname.split('.');
    for (let i = 0; i < labels.length; i++) {
      if (labels[i].length > 63) {
        return false;
      }
    }
  }
  return valid;
};

const ipv4Validator: FormatValidatorFn = (ipv4: unknown) => {
  if (typeof ipv4 !== 'string') {
    return true;
  }
  return isIPModule.default(ipv4, 4);
};

const ipv6Validator: FormatValidatorFn = (ipv6: unknown) => {
  if (typeof ipv6 !== 'string') {
    return true;
  }
  if (ipv6.includes('%')) {
    return false;
  }
  return isIPModule.default(ipv6, 6);
};

const regexValidator: FormatValidatorFn = (input: unknown) => {
  if (typeof input !== 'string') {
    return false;
  }
  try {
    RegExp(input);
    return true;
  } catch (_e) {
    return false;
  }
};

const strictUriValidator: FormatValidatorFn = (uri: unknown) => typeof uri !== 'string' || isURLModule.default(uri);

const uriValidator: FormatValidatorFn = function (uri: unknown) {
  // https://github.com/zaggino/z-schema/issues/18
  // RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
  return typeof uri !== 'string' || RegExp('^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?').test(uri);
};

export interface FormatValidatorsOptions {
  strictUris?: boolean;
  customFormats?: Record<string, FormatValidatorFn | null>;
}

const inbuiltValidators: Record<string, FormatValidatorFn> = {
  date: dateValidator,
  'date-time': dateTimeValidator,
  email: emailValidator,
  hostname: hostnameValidator,
  'host-name': hostnameValidator,
  ipv4: ipv4Validator,
  ipv6: ipv6Validator,
  regex: regexValidator,
  uri: uriValidator,
  'strict-uri': strictUriValidator,
} as const;

const customValidators: Record<string, FormatValidatorFn> = {};

export function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn> {
  return {
    ...inbuiltValidators,
    ...(options?.strictUris ? { uri: strictUriValidator } : {}),
    ...customValidators,
    ...(options?.customFormats || {}),
  };
}

export function registerFormat(name: string, validatorFunction: FormatValidatorFn) {
  customValidators[name] = validatorFunction;
}

export function unregisterFormat(name: string) {
  delete customValidators[name];
}

export function getSupportedFormats() {
  return sortedKeys({
    ...inbuiltValidators,
    ...customValidators,
  });
}

export function isFormatSupported(
  name: string,
  options?: { customFormats?: Record<string, FormatValidatorFn | null> }
): boolean {
  return !!(
    inbuiltValidators[name] != null ||
    customValidators[name] != null ||
    (options?.customFormats && options.customFormats[name] != null)
  );
}

export function getRegisteredFormats() {
  return sortedKeys(customValidators);
}

1	import isEmailModule from 'validator/lib/isEmail.js';
2	import isIPModule from 'validator/lib/isIP.js';
3	import isURLModule from 'validator/lib/isURL.js';
4	import { sortedKeys } from './utils/json.js';
5
6	export type FormatValidatorFn = (input: unknown) => boolean \| Promise<boolean>;
7
8	const dateValidator: FormatValidatorFn = (date: unknown) => {	69✔
9	if (typeof date !== 'string') {	×
10	return true;	×
11	}
12	// full-date from http://tools.ietf.org/html/rfc3339#section-5.6
13	const matches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(date);	×
14	if (matches === null) {	×
15	return false;	×
16	}
17	// var year = matches[1];
18	// var month = matches[2];
19	// var day = matches[3];
20	if (matches[2] < '01' \|\| matches[2] > '12' \|\| matches[3] < '01' \|\| matches[3] > '31') {	×
21	return false;	×
22	}
23	return true;	×
24	};
25
26	const dateTimeValidator: FormatValidatorFn = (dateTime: unknown) => {	69✔
27	if (typeof dateTime !== 'string') {	128✔
28	return true;	48✔
29	}
30	// date-time from http://tools.ietf.org/html/rfc3339#section-5.6
31	const s = dateTime.toLowerCase().split('t');	80✔
32	if (s.length !== 2) {	80✔
33	return false;	×
34	}
35	const datePart = s[0];	80✔
36	const timePart = s[1];	80✔
37	// Check date
38	const dateMatches = /^([0-9]{4})-([0-9]{2})-([0-9]{2})$/.exec(datePart);	80✔
39	if (dateMatches === null) {	80✔
40	return false;	24✔
41	}
42	const year = parseInt(dateMatches[1], 10);	56✔
43	const month = parseInt(dateMatches[2], 10);	56✔
44	const day = parseInt(dateMatches[3], 10);	56✔
45	if (month < 1 \|\| month > 12 \|\| day < 1 \|\| day > 31) {	56✔
NEW 46	return false;	×
47	}
48	// Check if date is valid
49	const date = new Date(year, month - 1, day);	56✔
50	if (date.getFullYear() !== year \|\| date.getMonth() !== month - 1 \|\| date.getDate() !== day) {	56✔
51	return false;	4✔
52	}
53	// Check time
54	const timeMatches = /^([0-9]{2}):([0-9]{2}):([0-9]{2})(.[0-9]+)?(z\|([+-][0-9]{2}:[0-9]{2}))$/.exec(timePart);	52✔
55	if (timeMatches === null) {	52✔
56	return false;	8✔
57	}
58	const hour = parseInt(timeMatches[1], 10);	44✔
59	const minute = parseInt(timeMatches[2], 10);	44✔
60	const second = parseInt(timeMatches[3], 10);	44✔
61	if (hour > 23 \|\| minute > 59 \|\| second > 60) {	44✔
62	return false;	4✔
63	}
64	// Check offset
65	let utcHour = hour;	40✔
66	if (timeMatches[5] !== 'z') {	40✔
67	const offset = timeMatches[5];	16✔
68	const offsetMatches = /^([+-])([0-9]{2}):([0-9]{2})$/.exec(offset);	16✔
69	if (offsetMatches === null) {	16✔
NEW 70	return false;	×
71	}
72	const offsetSign = offsetMatches[1];	16✔
73	const offsetHour = parseInt(offsetMatches[2], 10);	16✔
74	const offsetMinute = parseInt(offsetMatches[3], 10);	16✔
75	if (offsetHour > 23 \|\| offsetMinute > 59) {	16✔
76	return false;	4✔
77	}
78	if (offsetSign === '+') {	12✔
79	utcHour = hour - offsetHour;	4✔
80	} else {
81	utcHour = hour + offsetHour;	8✔
82	}
83	utcHour = ((utcHour % 24) + 24) % 24;	12✔
84	}
85	// Leap second only at 23:59:60 UTC
86	if (second === 60) {	36✔
87	if (utcHour !== 23 \|\| minute !== 59) {	16✔
88	return false;	8✔
89	}
90	}
91	return true;	28✔
92	};
93
94	const emailValidator: FormatValidatorFn = (email: unknown) => {	69✔
95	if (typeof email !== 'string') {	120✔
96	return true;	48✔
97	}
98	return isEmailModule.default(email, { require_tld: true });	72✔
99	};
100
101	const hostnameValidator: FormatValidatorFn = (hostname: unknown) => {	69✔
102	if (typeof hostname !== 'string') {	136✔
103	return true;	48✔
104	}
105	/*
106	http://json-schema.org/latest/json-schema-validation.html#anchor114
107	A string instance is valid against this attribute if it is a valid
108	representation for an Internet host name, as defined by RFC 1034, section 3.1 [RFC1034].
109
110	http://tools.ietf.org/html/rfc1034#section-3.5
111
112	<digit> ::= any one of the ten digits 0 through 9
113	var digit = /[0-9]/;
114
115	<letter> ::= any one of the 52 alphabetic characters A through Z in upper case and a through z in lower case
116	var letter = /[a-zA-Z]/;
117
118	<let-dig> ::= <letter> \| <digit>
119	var letDig = /[0-9a-zA-Z]/;
120
121	<let-dig-hyp> ::= <let-dig> \| "-"
122	var letDigHyp = /[-0-9a-zA-Z]/;
123
124	<ldh-str> ::= <let-dig-hyp> \| <let-dig-hyp> <ldh-str>
125	var ldhStr = /[-0-9a-zA-Z]+/;
126
127	<label> ::= <letter> [ [ <ldh-str> ] <let-dig> ]
128	var label = /[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?/;
129
130	<subdomain> ::= <label> \| <subdomain> "." <label>
131	var subdomain = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/;
132
133	<domain> ::= <subdomain> \| " "
134	var domain = null;
135	*/
136	const valid = /^[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?(\.[a-zA-Z](([-0-9a-zA-Z]+)?[0-9a-zA-Z])?)*$/.test(hostname);	88✔
137	if (valid) {	88✔
138	// the sum of all label octets and label lengths is limited to 255.
139	if (hostname.length > 255) {	36✔
140	return false;	×
141	}
142	// Each node has a label, which is zero to 63 octets in length
143	const labels = hostname.split('.');	36✔
144	for (let i = 0; i < labels.length; i++) {	36✔
145	if (labels[i].length > 63) {	52✔
146	return false;	8✔
147	}
148	}
149	}
150	return valid;	80✔
151	};
152
153	const ipv4Validator: FormatValidatorFn = (ipv4: unknown) => {	69✔
154	if (typeof ipv4 !== 'string') {	92✔
155	return true;	48✔
156	}
157	return isIPModule.default(ipv4, 4);	44✔
158	};
159
160	const ipv6Validator: FormatValidatorFn = (ipv6: unknown) => {	69✔
161	if (typeof ipv6 !== 'string') {	188✔
162	return true;	48✔
163	}
164	if (ipv6.includes('%')) {	140✔
165	return false;	4✔
166	}
167	return isIPModule.default(ipv6, 6);	136✔
168	};
169
170	const regexValidator: FormatValidatorFn = (input: unknown) => {	69✔
171	if (typeof input !== 'string') {	72✔
172	return false;	×
173	}
174	try {	72✔
175	RegExp(input);	72✔
176	return true;	72✔
177	} catch (_e) {
178	return false;	×
179	}
180	};
181
182	const strictUriValidator: FormatValidatorFn = (uri: unknown) => typeof uri !== 'string' \|\| isURLModule.default(uri);	69✔
183
184	const uriValidator: FormatValidatorFn = function (uri: unknown) {	69✔
185	// https://github.com/zaggino/z-schema/issues/18
186	// RegExp from http://tools.ietf.org/html/rfc3986#appendix-B
187	return typeof uri !== 'string' \|\| RegExp('^(([^:/?#]+):)?(//([^/?#]))?([^?#])(\\?([^#]))?(#(.))?').test(uri);	24✔
188	};
189
190	export interface FormatValidatorsOptions {
191	strictUris?: boolean;
192	customFormats?: Record<string, FormatValidatorFn \| null>;
193	}
194
195	const inbuiltValidators: Record<string, FormatValidatorFn> = {	69✔
196	date: dateValidator,
197	'date-time': dateTimeValidator,
198	email: emailValidator,
199	hostname: hostnameValidator,
200	'host-name': hostnameValidator,
201	ipv4: ipv4Validator,
202	ipv6: ipv6Validator,
203	regex: regexValidator,
204	uri: uriValidator,
205	'strict-uri': strictUriValidator,
206	} as const;
207
208	const customValidators: Record<string, FormatValidatorFn> = {};	69✔
209
210	export function getFormatValidators(options?: FormatValidatorsOptions): Record<string, FormatValidatorFn> {
211	return {	1,106✔
212	...inbuiltValidators,
213	...(options?.strictUris ? { uri: strictUriValidator } : {}),
214	...customValidators,
215	...(options?.customFormats \|\| {}),
216	};
217	}
218
219	export function registerFormat(name: string, validatorFunction: FormatValidatorFn) {
220	customValidators[name] = validatorFunction;	116✔
221	}
222
223	export function unregisterFormat(name: string) {
224	delete customValidators[name];	×
225	}
226
227	export function getSupportedFormats() {
228	return sortedKeys({	×
229	...inbuiltValidators,
230	...customValidators,
231	});
232	}
233
234	export function isFormatSupported(
235	name: string,
236	options?: { customFormats?: Record<string, FormatValidatorFn \| null> }
237	): boolean {
238	return !!(	4,801✔
239	inbuiltValidators[name] != null \|\|
240	customValidators[name] != null \|\|
241	(options?.customFormats && options.customFormats[name] != null)
242	);
243	}
244
245	export function getRegisteredFormats() {
246	return sortedKeys(customValidators);	×
247	}

zaggino / z-schema / 21777411725

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous