url-templates 1.0.0 → 1.0.2

package/#/tests/0/0.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid non strings",
+    "data": 12,
+    "valid": false
+}

package/#/tests/0/1.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid key character (contains !)",
+    "data": "{fo!o}",
+    "valid": false
+}

package/#/tests/0/10.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid consecutive varspec delimiters , ,",
+    "data": "{foo,,bar}",
+    "valid": false
+}

package/#/tests/0/11.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid consecutive prefix delimiters ::",
+    "data": "{foo::3}",
+    "valid": false
+}

package/#/tests/0/12.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid only literal (no expressions)",
+    "data": "abc-XYZ_123~",
+    "valid": true
+}

package/#/tests/0/13.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid literal before, expression, literal after",
+    "data": "path/{foo}/end",
+    "valid": true
+}

package/#/tests/0/14.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid literal before, expression, literal middle, expression, literal after",
+    "data": "x{foo}y{bar}z",
+    "valid": true
+}

package/#/tests/0/15.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid expression: single key, no operator",
+    "data": "{foo}",
+    "valid": true
+}

package/#/tests/0/16.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid expression: single key with operator +",
+    "data": "{+foo}",
+    "valid": true
+}

package/#/tests/0/17.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid expression: single key with prefix",
+    "data": "{foo:3}",
+    "valid": true
+}

package/#/tests/0/18.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid expression: single key with explode",
+    "data": "{foo*}",
+    "valid": true
+}

package/#/tests/0/19.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid expression: multiple keys separated by comma, each having prefix or explode",
+    "data": "{foo:2,bar*,baz:4}",
+    "valid": true
+}

package/#/tests/0/2.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid operator (invalid symbol ^)",
+    "data": "{^foo}",
+    "valid": false
+}

package/#/tests/0/20.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid expression: with operator and multiple keys",
+    "data": "{+foo,bar*}",
+    "valid": true
+}

package/#/tests/0/21.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid percent encoding (incomplete)",
+    "data": "{foo%2}",
+    "valid": false
+}

package/#/tests/0/22.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid percent-encoded key",
+    "data": "{foo%20bar}",
+    "valid": true
+}

package/#/tests/0/23.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid literal contains control character",
+    "data": "abc\u0001def",
+    "valid": false
+}

package/#/tests/0/24.json

@@ -0,0 +1,5 @@
+{
+    "description": "valid mix of multiple expressions and literals",
+    "data": "http://example.com/{+path}/details/{id*}",
+    "valid": true
+}

package/#/tests/0/25.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid literal character (space not allowed)",
+    "data": "foo bar",
+    "valid": false
+}

package/#/tests/0/3.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid char after explode modifier",
+    "data": "{foo*1}",
+    "valid": false
+}

package/#/tests/0/4.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid prefix type (non-digit after :)",
+    "data": "{foo:ab}",
+    "valid": false
+}

package/#/tests/0/5.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid prefix length (too large number)",
+    "data": "{foo:12345}",
+    "valid": false
+}

package/#/tests/0/6.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid { in literal part",
+    "data": "foo{bar",
+    "valid": false
+}

package/#/tests/0/7.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid } in literal part",
+    "data": "foo}bar",
+    "valid": false
+}

package/#/tests/0/8.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid modifier having both prefix and explode",
+    "data": "{foo:3*}",
+    "valid": false
+}

package/#/tests/0/9.json

@@ -0,0 +1,5 @@
+{
+    "description": "invalid empty key",
+    "data": "{,foo}",
+    "valid": false
+}

package/#/tests/0/schema.json

@@ -0,0 +1,4 @@
+{
+    "$comment": "dry validation related tests only",
+    "$ref": "#/#/#/#/uri-template"
+}

package/index.js

@@ -5,7 +5,11 @@ const operators = new Set(['+', '#', '.', '/', '?', '&', ';']);
 const separator = (operator) => (operator === '' || operator === '+' || operator == '#' ? ',' : operator === '?' ? '&' : operator);
 const isDefined = (value) => value !== undefined && value !== null;
 const encodeUnreserved = (string) => encodeURIComponent(string).replace(/[!'()*]/g, (char) => '%' + char.charCodeAt(0).toString(16).toUpperCase());
-const encodeReserved = (string) => string.split(/(%[0-9A-Fa-f]{2})/g).map((part, i) => (i % 2 ? part : encodeURI(part).replace(/%5B/g, '[').replace(/%5D/g, ']'))).join('');
+const encodeReserved = (string) =>
+    string
+        .split(/(%[0-9A-Fa-f]{2})/g)
+        .map((part, i) => (i % 2 ? part : encodeURI(part).replace(/%5B/g, '[').replace(/%5D/g, ']')))
+        .join('');
 const encodeValue = (operator, value, key) => {
     value = operator === '+' || operator === '#' ? encodeReserved(value) : encodeUnreserved(value);
     return key ? encodeReserved(key) + '=' + value : value;
@@ -14,28 +18,32 @@ const ast = [];
 // url-template validator
 function isUrlTemplate(template, inspect) {
     if (typeof template !== 'string') throw new TypeError('uri-template must be a string.');
-    if (!/^[A-Za-z0-9\-._~:/?#\[\]@!$&'()*+,;=%{}]*$/.test(template)) throw new Error('invalid character(s) in uri-template.');
+    if (!/^[A-Za-z0-9\-._~:/?#\[\]@!$&'()*+,;=%{}]*$/.test(template)) throw new SyntaxError('invalid character(s) in uri-template.');
     for (let i = 0; i < template.length; ) {
         const start = template.indexOf('{', i);
-        if ((start === -1 && template.indexOf('}', i) > start) || template.indexOf('}', i) < start) throw new Error('unstarted expression in uri-template');
-        if (start === -1) { inspect && ast.push(template.slice(i)); break; }
+        const nextClose = template.indexOf('}', i);
+        if (nextClose !== -1 && (start === -1 || nextClose < start)) throw new SyntaxError(`at index ${nextClose}: unstarted expression in uri-template.`);
+        if (start === -1) {
+            inspect && ast.push(template.slice(i));
+            break;
+        }
         if (inspect && start > i) ast.push(template.slice(i, start));
         const end = template.indexOf('}', start + 1);
-        if (end === -1) throw new Error('unterminated expression in uri-template.');
+        const nestedStart = template.indexOf('{', start + 1);
+        if (end === -1 || (nestedStart !== -1 && nestedStart < end)) throw new SyntaxError(`at index ${start}: unterminated expression in uri-template.`);
         let expression = template.slice(start + 1, end);
-        if (expression.length === 0) throw new Error('empty expression.');
+        if (expression.length === 0) throw new SyntaxError(`at index ${start + 1}: empty expression.`);
         const first = expression[0];
         const operator = operators.has(first) ? ((expression = expression.slice(1)), first) : '';
-        if (expression.length === 0) throw new Error('expression missing variable names.');
+        if (expression.length === 0) throw new SyntaxError(`at index ${start + 2}: expression missing variable names.`);
         const varspecs = expression.split(',').map((key) => {
             const colon = key.indexOf(':');
             const limit = colon !== -1 ? Number(key.slice(colon + 1)) : null;
-            if (isDefined(limit) && (limit % 1 !== 0 || isNaN(limit) || limit < 1 || limit > 9999)) throw new Error('invalid limit modifier.');
+            if (isDefined(limit) && (limit % 1 !== 0 || isNaN(limit) || limit < 1 || limit > 9999)) throw new SyntaxError(`at index ${start}: invalid limit modifier.`);
             if (limit) key = key.slice(0, colon);
             const explode = key.endsWith('*');
-            if (explode && limit) throw new Error('invalid modifier having both explode and limit.');
             if (explode) key = key.slice(0, -1);
-            if (!/^(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})+(?:\.(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})+)*$/.test(key)) throw new Error('invalid variable name in uri-template.');
+            if (!/^(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})+(?:\.(?:[A-Za-z0-9_]|%[0-9A-Fa-f]{2})+)*$/.test(key)) throw new SyntaxError(`at index ${operator ? start + 2 : start + 1}: invalid variable name in uri-template.`);
             return Object.assign({ key }, limit ? { limit } : explode ? { explode } : {});
         });
         if (inspect) ast.push({ [operator]: varspecs });
@@ -52,17 +60,19 @@ function parseTemplate(template, validate) {
                 if (first + expression) {
                     const values = [];
                     const operator = operators.has(first) ? first : ((expression = first + expression), '');
+                    let defined = expression.split(/,/g).length;
                     expression.split(/,/g).forEach((variable) => {
                         const match = /(?<key>[^:\*]*)(?::(?<length>\d+)|(?<explode>\*))?/.exec(variable).groups;
                         const key = match.key;
                         const value = vars[key];
+                        if (!isDefined(value)) defined--;
                         if (isDefined(value) && value !== '') {
                             if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
                                 let string = value.toString();
                                 if (match.length) string = string.substring(0, parseInt(match.length));
                                 values.push(encodeValue(operator, string, keyOperators.has(operator) ? key : ''));
                             } else {
-                                if (validate && match.length) throw new Error('invalid limit modifier on objects.');
+                                if (validate && match.length) throw new SyntaxError('invalid limit modifier on objects.');
                                 if (match.explode) {
                                     if (Array.isArray(value)) {
                                         value.filter(isDefined).forEach((item) => values.push(encodeValue(operator, item, keyOperators.has(operator) ? key : '')));
@@ -97,6 +107,7 @@ function parseTemplate(template, validate) {
                             }
                         }
                     });
+                    if (!defined && !validate) values.push(`{${expression}}`);
                     return (operator === '+' || values.length === 0 ? '' : operator) + values.join(separator(operator));
                 }
                 return encodeReserved(literal);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "url-templates",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A url-template validator, expander and inspector as defined by RFC 6570",
   "keywords": [
     "url",

package/readme.md

@@ -40,7 +40,7 @@ It returns `true` or throws an `error`.
 ```js title="js"
 const { inspect } = require('url-templates');
 try {
-    console.dir(inspect('/search{?q*,lang:2}'), { depth: null }); 
+    console.dir(inspect('/search{?q*,lang:2}'), { depth: null });
     // [ '/search', { '?': [ { key: 'q', explode: true }, { key: 'lang', limit: 2 } ] } ]
 } catch (error) {
     console.error('invalid:', error.message);
@@ -69,9 +69,36 @@ If valid returns the `expand(vars)` function which returns the expanded `url-tem
 ```js title="js"
 const { compile } = require('url-templates');
 console.log(compile('/broken{').expand({})); // returns '/broken{'; invalid parts left for postprocessing
-console.log(compile('/good{id}').expand({id:42})); // returns '/good42'; 
+console.log(compile('/good{id}').expand({ id: 42 })); // returns '/good42';
+console.log(compile('/undefined{id}').expand({ id: undefined })); // returns '/undefined{id}';
 ```
 
 **Note:**
-Returns a usable expander without validation (for cases where validation is done elsewhere, or for the cases where some sort of postprocessing will follow).
+Returns a usable expander without validation for cases where validation is done elsewhere, or for the cases where some sort of postprocessing will follow. A good example of postprocessing is described next:
 
+### Multi pass expansion without validation
+
+**Example 1**
+
+```js title="js"
+const { compile } = require('url-templates');
+const vars1 = { anotherPattern: '{foo}', andAnotherPattern: '{bar,baz}' };
+const vars2 = { foo: 1, bar: 2, baz: 3 };
+const firstPass = decodeURIComponent(compile('[{anotherPattern},{andAnotherPattern}]').expand(vars1));
+console.log(firstPass); // returns '[{foo},{bar,baz}]';
+console.log(compile(firstPass).expand(vars2)); // returns '[1,2,3]';
+```
+
+**Example 2**
+
+```js title="js"
+const { compile } = require('url-templates');
+const vars1 = { foo: 1 };
+const vars2 = { bar: 2, baz: 3 };
+const firstPass = decodeURIComponent(compile('[{foo},{bar,baz}]').expand(vars1));
+console.log(firstPass); // returns '[1,{bar,baz}]';
+console.log(compile(firstPass).expand(vars2)); // returns '[1,2,3]';
+```
+
+**Important Note:**
+The first pass will preserve the `{bar,baz}` expression only if the supplied variable has **none** of its members. This method can also be used to preserve quantifiers like `{1,4}` in regular expresions.