Browse files

url: port WHATWG URL API to internal/errors

Also slightly revises grammar.

PR-URL: #12574
Refs: #11273
Refs: #11299
Reviewed-By: James M Snell <>
Reviewed-By: Joyee Cheung <>
Reviewed-By: Daijiro Wachi <>
  • Loading branch information...
TimothyGu committed Apr 21, 2017
1 parent b7a341d commit d457a986a01b84c4cee3a952082caac3f118e1db
@@ -563,6 +563,13 @@ found [here][online].
<a id="nodejs-error-codes"></a>
## Node.js Error Codes
+<a id="ERR_ARG_NOT_ITERABLE"></a>
+The `'ERR_ARG_NOT_ITERABLE'` error code is used generically to identify that an
+iterable argument (i.e. a value that works with `for...of` loops) is required,
+but not provided to a Node.js API.
@@ -575,6 +582,76 @@ an argument of the wrong type has been passed to a Node.js API.
The `'ERR_INVALID_CALLBACK'` error code is used generically to identify that
a callback function is required and has not been provided to a Node.js API.
+An error with the `'ERR_INVALID_FILE_URL_HOST'` code may be thrown when a
+Node.js API that consumes `file:` URLs (such as certain functions in the
+[`fs`][] module) encounters a file URL with an incompatible host. Currently,
+this situation can only occur on Unix-like systems, where only `localhost` or
+an empty host is supported.
+An error with the `'ERR_INVALID_FILE_URL_PATH'` code may be thrown when a
+Node.js API that consumes `file:` URLs (such as certain functions in the
+[`fs`][] module) encounters a file URL with an incompatible path. The exact
+semantics for determining whether a path can be used is platform-dependent.
+<a id="ERR_INVALID_THIS"></a>
+The `'ERR_INVALID_THIS'` error code is used generically to identify that a
+Node.js API function is called with an incompatible `this` value.
+const { URLSearchParams } = require('url');
+const urlSearchParams = new URLSearchParams('foo=bar&baz=new');
+const buf = Buffer.alloc(1);, 'foo');
+ // Throws a TypeError with code 'ERR_INVALID_THIS'
+<a id="ERR_INVALID_TUPLE"></a>
+An error with code `'ERR_INVALID_TUPLE'` is thrown when an element in the
+`iterable` provided to the [WHATWG][WHATWG URL API] [`URLSearchParams`
+constructor][`new URLSearchParams(iterable)`] does not represent a `[name,
+value]` tuple – that is, if an element is not iterable, or does not consist of
+exactly two elements.
+<a id="ERR_INVALID_URL"></a>
+An error using the `'ERR_INVALID_URL'` code is thrown when an invalid URL is
+passed to the [WHATWG][WHATWG URL API] [`URL` constructor][`new URL(input)`] to
+be parsed. The thrown error object typically has an additional property
+`'input'` that contains the URL that failed to parse.
+The code `'ERR_INVALID_URL_SCHEME'` is used generically to signify an attempt
+to use a URL of an incompatible scheme (aka protocol) for a specific purpose.
+It is currently only used in the [WHATWG URL API][] support in the [`fs`][]
+module (which only accepts URLs with `'file'` scheme), but may be used in other
+Node.js APIs as well in the future.
+<a id="ERR_MISSING_ARGS"></a>
+The `'ERR_MISSING_ARGS'` error code is a generic error code for instances where
+a required argument of a Node.js API is not passed. This is currently only used
+in the [WHATWG URL API][] for strict compliance with the specification (which
+in some cases may accept `func(undefined)` but not `func()`). In most native
+Node.js APIs, `func(undefined)` and `func()` are treated identically, and the
+[`ERR_INVALID_ARG_TYPE`][] error code may be used instead.
<a id="ERR_STDERR_CLOSE"></a>
@@ -627,11 +704,15 @@ likely an indication of a bug within Node.js itself.
[`process.on('uncaughtException')`]: process.html#process_event_uncaughtexception
[domains]: domain.html
[event emitter-based]: events.html#events_class_eventemitter
[file descriptors]:
[Node.js Error Codes]: #nodejs-error-codes
[stream-based]: stream.html
+[`new URL(input)`]: url.html#url_constructor_new_url_input_base
+[`new URLSearchParams(iterable)`]: url.html#url_constructor_new_urlsearchparams_iterable
[V8's stack trace API]:
[vm]: vm.html
+[WHATWG URL API]: url.html#url_the_whatwg_url_api
@@ -79,9 +79,18 @@ module.exports = exports = {
// Any error code added here should also be added to the documentation
// Note: Please try to keep these in alphabetical order
+E('ERR_ARG_NOT_ITERABLE', '%s must be iterable');
E('ERR_ASSERTION', (msg) => msg);
E('ERR_INVALID_ARG_TYPE', invalidArgType);
E('ERR_INVALID_CALLBACK', 'callback must be a function');
+E('ERR_INVALID_FILE_URL_HOST', 'File URL host %s');
+E('ERR_INVALID_FILE_URL_PATH', 'File URL path %s');
+E('ERR_INVALID_THIS', 'Value of "this" must be of type %s');
+E('ERR_INVALID_TUPLE', '%s must be an iterable %s tuple');
+E('ERR_INVALID_URL', 'Invalid URL: %s');
+ (expected) => `The URL must be ${oneOf(expected, 'scheme')}`);
+E('ERR_MISSING_ARGS', missingArgs);
E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');
E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');
E('ERR_UNKNOWN_STDIN_TYPE', 'Unknown stdin file type');
@@ -91,22 +100,49 @@ E('ERR_UNKNOWN_BUILTIN_MODULE', (id) => `No such built-in module: ${id}`);
function invalidArgType(name, expected, actual) {
assert(name, 'name is required');
+ var msg = `The "${name}" argument must be ${oneOf(expected, 'type')}`;
+ if (arguments.length >= 3) {
+ msg += `. Received type ${actual !== null ? typeof actual : 'null'}`;
+ }
+ return msg;
+function missingArgs(...args) {
+ assert(args.length > 0, 'At least one arg needs to be specified');
+ let msg = 'The ';
+ const len = args.length;
+ args = => `"${a}"`);
+ switch (len) {
+ case 1:
+ msg += `${args[0]} argument`;
+ break;
+ case 2:
+ msg += `${args[0]} and ${args[1]} arguments`;
+ break;
+ default:
+ msg += args.slice(0, len - 1).join(', ');
+ msg += `, and ${args[len - 1]} arguments`;
+ break;
+ }
+ return `${msg} must be specified`;
+function oneOf(expected, thing) {
assert(expected, 'expected is required');
- var msg = `The "${name}" argument must be `;
+ assert(typeof thing === 'string', 'thing is required');
if (Array.isArray(expected)) {
- var len = expected.length;
+ const len = expected.length;
+ assert(len > 0, 'At least one expected value needs to be specified');
expected = => String(i));
- if (len > 1) {
- msg += `one of type ${expected.slice(0, len - 1).join(', ')}, or ` +
+ if (len > 2) {
+ return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
expected[len - 1];
+ } else if (len === 2) {
+ return `one of ${thing} ${expected[0]} or ${expected[1]}`;
} else {
- msg += `of type ${expected[0]}`;
+ return `of ${thing} ${expected[0]}`;
} else {
- msg += `of type ${String(expected)}`;
- }
- if (arguments.length >= 3) {
- msg += `. Received type ${actual !== null ? typeof actual : 'null'}`;
+ return `of ${thing} ${String(expected)}`;
- return msg;
Oops, something went wrong.

0 comments on commit d457a98

Please sign in to comment.