upd dependencies and fixed refs to files from all parts of document: '' and 'with'

Author: funduck

clone.js

@@ -0,0 +1,33 @@
+module.exports = function (obj) {
+    switch (typeof obj) {
+        case 'undefined':
+        case 'string':
+        case 'boolean':
+        case 'number':
+        case 'function':
+            return obj;
+    }
+
+    if (obj == null) {
+        return null;
+    }
+
+    if (obj instanceof Date) {
+        return new Date(obj);
+    }
+
+    if (obj instanceof RegExp) {
+        throw new Error('dunno how to clone', obj);
+        //console.error('clone RegExp is unsafe');
+        //return RegExp(obj);
+    }
+
+    if (typeof obj != 'object' && !Array.isArray(obj)) {
+        throw new Error('dunno how to clone', obj);
+    }
+    const newObj = (Array.isArray(obj)) ? [] : {};
+    for (const i in obj) {
+        newObj[i] = module.exports(obj[i]);
+    }
+    return newObj;
+};

index.js

@@ -4,6 +4,8 @@ const fs = require('fs');
 const jsonPatch = require('rfc6902');
 const refParser = require('./patched-json-schema-ref-parser');
 const jps = require('./json-pointer-selectors');
+const jsonPtr = require('json-ptr');
+const clone = require('./clone');
 
 /**
     @param {object} doc
@@ -13,37 +15,70 @@ const jps = require('./json-pointer-selectors');
     
     @return {object} doc - modified source
 */
-const inherit = function (doc, options) {
+const applyInherit = function (doc, options, rootDoc, inWith) {
     if (typeof doc != 'object' || doc == null) return doc;
-    
+   
+    rootDoc = rootDoc || doc;
     options = options || {};
     if (options.inherit == null) {
         return doc;
     }
     if (options.inherit === true) {
         options.inherit = '$inherit';
     }
+
+    const $inherit = options.inherit;
+    const _inherit = encodeURIComponent($inherit);
+    const re_inherit = new RegExp(`\/${_inherit}\/source`, 'g');
+    const _source = `${_inherit}\/source`; 
+    const re_source = new RegExp(`^(.*\/)${_source}\/?(.*)`);
+    const _with = `${_inherit}\/with`; 
+    const re_with = new RegExp(`^(.*\/)${_with}\/?(.*)`);
+
     if (Array.isArray(doc)) {
         for (let i = 0; i < doc.length; i++) {
-            doc[i] = inherit(doc[i], options);
+            doc[i] = applyInherit(doc[i], options, rootDoc, inWith);
         }
     } else {
         for (const key in doc) {
             if (key == '$ref') {
                 if (!doc.$ref.match(/^#/)) {
                     throw new Error('inherit: all outer references \'$ref\' must be resolved!');
                 } else {
-                    // fix internal references, if they have '/$inherit/source', it is correct for bundling
-                    // but we are going to move object 2 levels up, so it won't be correct
-                    doc.$ref = doc.$ref.replace(new RegExp(`\/${encodeURIComponent(options.inherit)}\/source`, 'g'), '');
+                    // if internal references are like '/$inherit/source*' we just bring the document
+                    // because after applying json-patch these references will be invalid
+                    const re = doc.$ref.match(re_source);
+                    if (re) {
+//console.error('found source ref', doc)
+                        // pointer to whole document under key 'source'
+                        if (inWith || !re[2]) {
+//console.error('cloning document', doc.$ref, re, re_source)
+                            return clone(jsonPtr.get(rootDoc, doc.$ref));
+                        } else {
+//console.error('replacing $ref', doc.$ref, re, re_source)
+                            doc.$ref = doc.$ref.replace(re_inherit, '');
+                        }
+                    } else {
+                        // if internal references are like '/$inherit/with*' we just bring the document
+                        // because after applying json-patch these references will be invalid
+                        const re = doc.$ref.match(re_with);
+                        if (re) {
+//console.error('found with ref', doc)
+                            // pointer to whole document under key 'source'
+//console.error('cloning document', doc.$ref, re, re_with)
+                            return clone(jsonPtr.get(rootDoc, doc.$ref));
+                        }
+                    }
                 }
             }
-            doc[key] = inherit(doc[key], options);
+            if (key in doc) {
+                doc[key] = applyInherit(doc[key], options, rootDoc, key == 'with' || inWith);
+            }
         }
-        if (options.inherit && doc[options.inherit]) {
-            const inh = doc[options.inherit];
+        if (doc[$inherit]) {
+            const inh = doc[$inherit];
             if (inh.source == null) {
-                throw new Error(`inherit: ${options.inherit}.source is null!`);
+                throw new Error(`inherit: ${$inherit}.source is null!`);
             }
             if (!(inh.with == null || Array.isArray(inh.with) && inh.with.length == 0)) {
                 const patch = (options.compileJsonPatch || jps.compileJsonPatch)(inh.source, inh.with)
@@ -67,6 +102,7 @@ const inherit = function (doc, options) {
     @return {Promise.<object>}
 */
 const bundle = function (filepath, options) {
+//console.error('Bundle()')
     if (!fs.existsSync(filepath)) {
         return new Promise((res, rej) => rej(new Error(`invalid argument: file "${filepath}" not exists`)));
     }
@@ -78,9 +114,9 @@ const bundle = function (filepath, options) {
     return parser.bundle(filepath)
     .then((doc) => {
         try {
-            doc = inherit(doc, options);
+            doc = applyInherit(doc, options);
         } catch (e) {
-            console.error('inherit', 'doc:', doc, 'error:', e);
+            console.error('inherit', 'doc:', JSON.stringify(doc, null, '  '), 'error:', e);
             throw e;
         }
         return doc;
@@ -100,14 +136,15 @@ const bundle = function (filepath, options) {
     @return {Promise.<object>}
 */
 const dereference = function (doc, options) {
+//console.error('Dereference()')
     if (typeof doc == 'string') {
         return bundle(doc, options)
         .then((doc) => {
             return dereference(doc);
         });
     }
     try {
-        doc = inherit(doc, options);
+        doc = applyInherit(doc, options);
     } catch (e) {
         console.error('inherit', 'doc:', doc, 'error:', e);
         return new Promise(function(resolve, reject) {

json-pointer-selectors.js

@@ -201,6 +201,59 @@ const objectMatchesSelector = (obj, selector) => {
     return true;
 };
 
+const compileOperation = (source, op) => {
+    const re = parseJsonPointer(op.path);
+
+    if (re.selector) {
+        const arr = jsonPtr.get(source, re.prefix);
+
+        // if object is not array check deeper
+        if (!Array.isArray(arr)) {
+            // if there is something to check deeper
+            if (arr[re.infix] != undefined && re.suffix != '') {
+                // relative pathes
+                op = compileOperation(arr[re.infix], Object.assign({}, op, {path: re.suffix}));
+                // relative pathes back to absolute
+                op.path = re.prefix + re.infix + op.path;
+            }
+            return op;
+        }
+
+        // if found array check conditions
+        let found;
+        for (let j = 0; j < arr.length; j++) {
+            if (objectMatchesSelector(arr[j], re.selector)) {
+                if (found) {
+//console.error(re.selector)
+//console.error('first match:', found)
+//console.error('new match:', j, arr[j])
+                    throw new Error(`path ${op.path} compiles to selector that has multiple matches, it is forbidden`);
+                }
+                const tmp = Object.assign({}, op, {path: re.suffix});
+                if (compileOperation(arr[j], tmp)) {
+                    // changing path to JSON-Pointer with number
+                    found = Object.assign({}, op, {path: re.prefix + '/' + j + re.suffix});
+                }
+            }
+        }
+        if (found) {
+            // checking new pathes deeper
+            return compileOperation(source, found);
+        }
+        return null;
+        //throw new Error(`path ${op.path} compiles to selector that has no matches`);
+    }
+
+    // all path exists or "op" is adding a new leaf 
+    if (jsonPtr.get(source, op.path)
+    || op.op == 'add' && jsonPtr.get(source, op.path.match(/(^.*)\/[^\/]*/)[1])
+    ) {
+        return op;
+    }
+
+    return null;
+};
+
 /**
     @param {object} source - object to which patch will be applied
     @param {Array} patchOperations
@@ -210,48 +263,12 @@ const objectMatchesSelector = (obj, selector) => {
 const compileJsonPatch = (source, patchOperations) => {
     const res = [];
     for (let i = 0; i < patchOperations.length; i++) {
-        if (!patchOperations[i].path) continue;
+        const op = patchOperations[i];
+        if (!op.path) continue;
 
-        const re = parseJsonPointer(patchOperations[i].path);
-        if (re.selector) {
-            const arr = jsonPtr.get(source, re.prefix);
-            let tmp = [];
-            // if object is not array check deeper
-            if (!Array.isArray(arr)) {
-                if (arr[re.infix] != undefined && re.suffix != '') {
-                    // relative pathes
-                    tmp = compileJsonPatch(arr[re.infix], [Object.assign({}, patchOperations[i], {path: re.suffix})]);
-                    for (let j = 0;j < tmp.length; j++) {
-                        // relative pathes back to absolute
-                        tmp[j].path = re.prefix + re.infix + tmp[j].path;
-                        res.push(tmp[j]);
-                    }
-                } else {
-                    res.push(patchOperations[i]);
-                }
-                continue;
-            }
-            // if found array check conditions
-            let found = false;
-            for (let j = 0; j < arr.length; j++) {
-                if (objectMatchesSelector(arr[j], re.selector)) {
-                    if (found) {
-                        throw new Error(`path ${patchOperations[i].path} compiles to selector that has multiple matches, it is forbidden`);
-                    }
-                    // changing path to JSON-Pointer with number
-                    tmp.push(Object.assign({}, patchOperations[i], {path: re.prefix + '/' + j + re.suffix}));
-                    found = true;
-                }
-            }
-            if (tmp.length) {
-                // checking new pathes deeper
-                tmp = compileJsonPatch(source, tmp);
-            }
-            if (tmp.length) {
-                res.push(...tmp);
-            }
-        } else {
-            res.push(patchOperations[i]);
+        const compiled = compileOperation(source, op);
+        if (compiled) {
+            res.push(compiled);
         }
     }
     return res;

package-lock.json

@@ -1,15 +1,15 @@
 {
   "name": "jybid",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "json yaml bundle inherit dereference",
   "main": "index.js",
   "directories": {
     "test": "test"
   },
   "dependencies": {
-    "json-ptr": "^1.1.2",
+    "json-ptr": "^1.2.0",
     "json-schema-ref-parser": "^6.1.0",
-    "rfc6902": "^3.0.2"
+    "rfc6902": "^3.0.4"
   },
   "devDependencies": {},
   "scripts": {