json-machete 0.3.5 → 0.3.6-alpha-983cd38bc.0

package/index.js

@@ -7,10 +7,10 @@ function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'defau
 const jsonPtr = require('json-ptr');
 const utils = require('@graphql-mesh/utils');
 const path = require('path');
-const util = require('util');
-const toJsonSchema = _interopDefault(require('to-json-schema'));
 const urlJoin = _interopDefault(require('url-join'));
 const crossUndiciFetch = require('cross-undici-fetch');
+const util = require('util');
+const toJsonSchema = _interopDefault(require('to-json-schema'));
 
 (function (OnCircularReference) {
     OnCircularReference["WARN"] = "WARN";
@@ -310,6 +310,154 @@ async function compareJSONSchemas(oldSchema, newSchema) {
     }
 }
 
+const resolvePath = (path, root) => {
+    return jsonPtr.JsonPointer.get(root, path);
+};
+function isRefObject(obj) {
+    return typeof obj === 'object' && obj.$ref;
+}
+function isURL(str) {
+    return /^https?:\/\//.test(str);
+}
+const getAbsolute$Ref = (given$ref, baseFilePath) => {
+    const [givenExternalFileRelativePath, givenRefPath] = given$ref.split('#');
+    if (givenExternalFileRelativePath) {
+        const cwd = isURL(baseFilePath) ? getCwdForUrl(baseFilePath) : path.dirname(baseFilePath);
+        const givenExternalFilePath = getAbsolutePath(givenExternalFileRelativePath, cwd);
+        if (givenRefPath) {
+            return `${givenExternalFilePath}#${givenRefPath}`;
+        }
+        return givenExternalFilePath;
+    }
+    return `${baseFilePath}#${givenRefPath}`;
+};
+function getCwdForUrl(url) {
+    const urlParts = url.split('/');
+    urlParts.pop();
+    return urlParts.join('/');
+}
+function normalizeUrl(url) {
+    return new URL(url).toString();
+}
+function getAbsolutePath(path$1, cwd) {
+    if (isURL(path$1)) {
+        return path$1;
+    }
+    if (isURL(cwd)) {
+        return normalizeUrl(urlJoin(cwd, path$1));
+    }
+    if (path.isAbsolute(path$1)) {
+        return path$1;
+    }
+    return path.join(cwd, path$1);
+}
+function getCwd(path$1) {
+    return isURL(path$1) ? getCwdForUrl(path$1) : path.dirname(path$1);
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+async function dereferenceObject(obj, { cwd = process.cwd(), externalFileCache = new Map(), refMap = new Map(), root = obj, fetch = crossUndiciFetch.fetch, headers, } = {}) {
+    if (typeof obj === 'object') {
+        if (isRefObject(obj)) {
+            const $ref = obj.$ref;
+            if (refMap.has($ref)) {
+                return refMap.get($ref);
+            }
+            else {
+                const [externalRelativeFilePath, refPath] = $ref.split('#');
+                if (externalRelativeFilePath) {
+                    const externalFilePath = getAbsolutePath(externalRelativeFilePath, cwd);
+                    const newCwd = getCwd(externalFilePath);
+                    let externalFile = externalFileCache.get(externalFilePath);
+                    if (!externalFile) {
+                        externalFile = await utils.readFileOrUrl(externalFilePath, {
+                            fetch,
+                            headers,
+                            cwd,
+                        }).catch(() => {
+                            throw new Error(`Unable to load ${externalRelativeFilePath} from ${cwd}`);
+                        });
+                        externalFileCache.set(externalFilePath, externalFile);
+                    }
+                    const result = await dereferenceObject(refPath
+                        ? {
+                            $ref: `#${refPath}`,
+                        }
+                        : externalFile, {
+                        cwd: newCwd,
+                        externalFileCache,
+                        refMap: new Proxy(refMap, {
+                            get: (originalRefMap, key) => {
+                                switch (key) {
+                                    case 'has':
+                                        return (given$ref) => {
+                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
+                                            return originalRefMap.has(original$Ref);
+                                        };
+                                    case 'get':
+                                        return (given$ref) => {
+                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
+                                            return originalRefMap.get(original$Ref);
+                                        };
+                                    case 'set':
+                                        return (given$ref, val) => {
+                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
+                                            return originalRefMap.set(original$Ref, val);
+                                        };
+                                }
+                                throw new Error('Not implemented ' + key.toString());
+                            },
+                        }),
+                        fetch,
+                        headers,
+                        root: externalFile,
+                    });
+                    refMap.set($ref, result);
+                    result.$resolvedRef = $ref;
+                    if (obj.title) {
+                        result.title = obj.title;
+                    }
+                    return result;
+                }
+                else {
+                    const resolvedObj = resolvePath(refPath, root);
+                    if (typeof resolvedObj === 'object' && !resolvedObj.$ref) {
+                        refMap.set($ref, resolvedObj);
+                    }
+                    const result = await dereferenceObject(resolvedObj, {
+                        cwd,
+                        externalFileCache,
+                        refMap,
+                        root,
+                        fetch,
+                        headers,
+                    });
+                    if (obj.title) {
+                        result.title = obj.title;
+                    }
+                    refMap.set($ref, result);
+                    result.$resolvedRef = $ref;
+                    return result;
+                }
+            }
+        }
+        else {
+            await Promise.all(Object.entries(obj).map(async ([key, val]) => {
+                if (typeof val === 'object') {
+                    obj[key] = await dereferenceObject(val, {
+                        cwd,
+                        externalFileCache,
+                        refMap,
+                        root,
+                        fetch,
+                        headers,
+                    });
+                }
+            }));
+        }
+    }
+    return obj;
+}
+
 const reservedTypeNames = ['Query', 'Mutation', 'Subscription'];
 function deduplicateJSONSchema(schema, seenMap = new Map()) {
     if (typeof schema === 'object' && schema != null) {
@@ -362,11 +510,12 @@ async function healJSONSchema(schema) {
                 delete subSchema.title;
             }
             if (!subSchema.title && !subSchema.$ref) {
+                const realPath = subSchema.$resolvedRef || path;
                 // Try to get definition name if missing
                 const splitByDefinitions = path.includes('/components/schemas/')
-                    ? path.split('/components/schemas/')
-                    : path.split('/definitions/');
-                const maybeDefinitionBasedPath = splitByDefinitions.length > 1 ? splitByDefinitions[splitByDefinitions.length - 1] : path;
+                    ? realPath.split('/components/schemas/')
+                    : realPath.split('/definitions/');
+                const maybeDefinitionBasedPath = splitByDefinitions.length > 1 ? splitByDefinitions[splitByDefinitions.length - 1] : realPath;
                 let pathBasedName = maybeDefinitionBasedPath
                     .split('/properties')
                     .join('')
@@ -459,150 +608,6 @@ async function healJSONSchema(schema) {
     });
 }
 
-const resolvePath = (path, root) => {
-    return jsonPtr.JsonPointer.get(root, path);
-};
-function isRefObject(obj) {
-    return typeof obj === 'object' && obj.$ref;
-}
-function isURL(str) {
-    return /^https?:\/\//.test(str);
-}
-const getAbsolute$Ref = (given$ref, baseFilePath) => {
-    const [givenExternalFileRelativePath, givenRefPath] = given$ref.split('#');
-    if (givenExternalFileRelativePath) {
-        const cwd = isURL(baseFilePath) ? getCwdForUrl(baseFilePath) : path.dirname(baseFilePath);
-        const givenExternalFilePath = getAbsolutePath(givenExternalFileRelativePath, cwd);
-        if (givenRefPath) {
-            return `${givenExternalFilePath}#${givenRefPath}`;
-        }
-        return givenExternalFilePath;
-    }
-    return `${baseFilePath}#${givenRefPath}`;
-};
-function getCwdForUrl(url) {
-    const urlParts = url.split('/');
-    urlParts.pop();
-    return urlParts.join('/');
-}
-function normalizeUrl(url) {
-    return new URL(url).toString();
-}
-function getAbsolutePath(path$1, cwd) {
-    if (isURL(path$1)) {
-        return path$1;
-    }
-    if (isURL(cwd)) {
-        return normalizeUrl(urlJoin(cwd, path$1));
-    }
-    if (path.isAbsolute(path$1)) {
-        return path$1;
-    }
-    return path.join(cwd, path$1);
-}
-function getCwd(path$1) {
-    return isURL(path$1) ? getCwdForUrl(path$1) : path.dirname(path$1);
-}
-// eslint-disable-next-line @typescript-eslint/ban-types
-async function dereferenceObject(obj, { cwd = process.cwd(), externalFileCache = new Map(), refMap = new Map(), root = obj, fetch = crossUndiciFetch.fetch, headers, } = {}) {
-    if (typeof obj === 'object') {
-        if (isRefObject(obj)) {
-            const $ref = obj.$ref;
-            if (refMap.has($ref)) {
-                return refMap.get($ref);
-            }
-            else {
-                const [externalRelativeFilePath, refPath] = $ref.split('#');
-                if (externalRelativeFilePath) {
-                    const externalFilePath = getAbsolutePath(externalRelativeFilePath, cwd);
-                    const newCwd = getCwd(externalFilePath);
-                    let externalFile = externalFileCache.get(externalFilePath);
-                    if (!externalFile) {
-                        externalFile = await utils.readFileOrUrl(externalFilePath, {
-                            fetch,
-                            headers,
-                            cwd,
-                        }).catch(() => {
-                            throw new Error(`Unable to load ${externalRelativeFilePath} from ${cwd}`);
-                        });
-                        externalFile = await healJSONSchema(externalFile);
-                        externalFileCache.set(externalFilePath, externalFile);
-                    }
-                    const result = await dereferenceObject(refPath
-                        ? {
-                            $ref: `#${refPath}`,
-                        }
-                        : externalFile, {
-                        cwd: newCwd,
-                        externalFileCache,
-                        refMap: new Proxy(refMap, {
-                            get: (originalRefMap, key) => {
-                                switch (key) {
-                                    case 'has':
-                                        return (given$ref) => {
-                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
-                                            return originalRefMap.has(original$Ref);
-                                        };
-                                    case 'get':
-                                        return (given$ref) => {
-                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
-                                            return originalRefMap.get(original$Ref);
-                                        };
-                                    case 'set':
-                                        return (given$ref, val) => {
-                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
-                                            return originalRefMap.set(original$Ref, val);
-                                        };
-                                }
-                                throw new Error('Not implemented ' + key.toString());
-                            },
-                        }),
-                        fetch,
-                        headers,
-                        root: externalFile,
-                    });
-                    refMap.set($ref, result);
-                    return result;
-                }
-                else {
-                    const resolvedObj = resolvePath(refPath, root);
-                    if (typeof resolvedObj === 'object' && !resolvedObj.$ref) {
-                        refMap.set($ref, resolvedObj);
-                    }
-                    const result = await dereferenceObject(resolvedObj, {
-                        cwd,
-                        externalFileCache,
-                        refMap,
-                        root,
-                        fetch,
-                        headers,
-                    });
-                    if (!result.title && obj.title) {
-                        result.title = obj.title;
-                    }
-                    refMap.set($ref, result);
-                    return result;
-                }
-            }
-        }
-        else {
-            await Promise.all(Object.entries(obj).map(async ([key, val]) => {
-                if (typeof val === 'object') {
-                    obj[key] = await dereferenceObject(val, {
-                        cwd,
-                        externalFileCache,
-                        refMap,
-                        root,
-                        fetch,
-                        headers,
-                    });
-                }
-            }));
-        }
-    }
-    return obj;
-}
-
 async function referenceJSONSchema(schema) {
     const definitions = {};
     const finalSchema = await visitJSONSchema(schema, subSchema => {

package/index.mjs

@@ -1,10 +1,10 @@
 import { JsonPointer } from 'json-ptr';
 import { AggregateError, readFileOrUrl } from '@graphql-mesh/utils';
 import { isAbsolute, join, dirname } from 'path';
-import { inspect } from 'util';
-import toJsonSchema from 'to-json-schema';
 import urlJoin from 'url-join';
 import { fetch } from 'cross-undici-fetch';
+import { inspect } from 'util';
+import toJsonSchema from 'to-json-schema';
 
 var OnCircularReference;
 (function (OnCircularReference) {
@@ -305,6 +305,154 @@ async function compareJSONSchemas(oldSchema, newSchema) {
     }
 }
 
+const resolvePath = (path, root) => {
+    return JsonPointer.get(root, path);
+};
+function isRefObject(obj) {
+    return typeof obj === 'object' && obj.$ref;
+}
+function isURL(str) {
+    return /^https?:\/\//.test(str);
+}
+const getAbsolute$Ref = (given$ref, baseFilePath) => {
+    const [givenExternalFileRelativePath, givenRefPath] = given$ref.split('#');
+    if (givenExternalFileRelativePath) {
+        const cwd = isURL(baseFilePath) ? getCwdForUrl(baseFilePath) : dirname(baseFilePath);
+        const givenExternalFilePath = getAbsolutePath(givenExternalFileRelativePath, cwd);
+        if (givenRefPath) {
+            return `${givenExternalFilePath}#${givenRefPath}`;
+        }
+        return givenExternalFilePath;
+    }
+    return `${baseFilePath}#${givenRefPath}`;
+};
+function getCwdForUrl(url) {
+    const urlParts = url.split('/');
+    urlParts.pop();
+    return urlParts.join('/');
+}
+function normalizeUrl(url) {
+    return new URL(url).toString();
+}
+function getAbsolutePath(path, cwd) {
+    if (isURL(path)) {
+        return path;
+    }
+    if (isURL(cwd)) {
+        return normalizeUrl(urlJoin(cwd, path));
+    }
+    if (isAbsolute(path)) {
+        return path;
+    }
+    return join(cwd, path);
+}
+function getCwd(path) {
+    return isURL(path) ? getCwdForUrl(path) : dirname(path);
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+async function dereferenceObject(obj, { cwd = process.cwd(), externalFileCache = new Map(), refMap = new Map(), root = obj, fetch: fetch$1 = fetch, headers, } = {}) {
+    if (typeof obj === 'object') {
+        if (isRefObject(obj)) {
+            const $ref = obj.$ref;
+            if (refMap.has($ref)) {
+                return refMap.get($ref);
+            }
+            else {
+                const [externalRelativeFilePath, refPath] = $ref.split('#');
+                if (externalRelativeFilePath) {
+                    const externalFilePath = getAbsolutePath(externalRelativeFilePath, cwd);
+                    const newCwd = getCwd(externalFilePath);
+                    let externalFile = externalFileCache.get(externalFilePath);
+                    if (!externalFile) {
+                        externalFile = await readFileOrUrl(externalFilePath, {
+                            fetch: fetch$1,
+                            headers,
+                            cwd,
+                        }).catch(() => {
+                            throw new Error(`Unable to load ${externalRelativeFilePath} from ${cwd}`);
+                        });
+                        externalFileCache.set(externalFilePath, externalFile);
+                    }
+                    const result = await dereferenceObject(refPath
+                        ? {
+                            $ref: `#${refPath}`,
+                        }
+                        : externalFile, {
+                        cwd: newCwd,
+                        externalFileCache,
+                        refMap: new Proxy(refMap, {
+                            get: (originalRefMap, key) => {
+                                switch (key) {
+                                    case 'has':
+                                        return (given$ref) => {
+                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
+                                            return originalRefMap.has(original$Ref);
+                                        };
+                                    case 'get':
+                                        return (given$ref) => {
+                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
+                                            return originalRefMap.get(original$Ref);
+                                        };
+                                    case 'set':
+                                        return (given$ref, val) => {
+                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
+                                            return originalRefMap.set(original$Ref, val);
+                                        };
+                                }
+                                throw new Error('Not implemented ' + key.toString());
+                            },
+                        }),
+                        fetch: fetch$1,
+                        headers,
+                        root: externalFile,
+                    });
+                    refMap.set($ref, result);
+                    result.$resolvedRef = $ref;
+                    if (obj.title) {
+                        result.title = obj.title;
+                    }
+                    return result;
+                }
+                else {
+                    const resolvedObj = resolvePath(refPath, root);
+                    if (typeof resolvedObj === 'object' && !resolvedObj.$ref) {
+                        refMap.set($ref, resolvedObj);
+                    }
+                    const result = await dereferenceObject(resolvedObj, {
+                        cwd,
+                        externalFileCache,
+                        refMap,
+                        root,
+                        fetch: fetch$1,
+                        headers,
+                    });
+                    if (obj.title) {
+                        result.title = obj.title;
+                    }
+                    refMap.set($ref, result);
+                    result.$resolvedRef = $ref;
+                    return result;
+                }
+            }
+        }
+        else {
+            await Promise.all(Object.entries(obj).map(async ([key, val]) => {
+                if (typeof val === 'object') {
+                    obj[key] = await dereferenceObject(val, {
+                        cwd,
+                        externalFileCache,
+                        refMap,
+                        root,
+                        fetch: fetch$1,
+                        headers,
+                    });
+                }
+            }));
+        }
+    }
+    return obj;
+}
+
 const reservedTypeNames = ['Query', 'Mutation', 'Subscription'];
 function deduplicateJSONSchema(schema, seenMap = new Map()) {
     if (typeof schema === 'object' && schema != null) {
@@ -357,11 +505,12 @@ async function healJSONSchema(schema) {
                 delete subSchema.title;
             }
             if (!subSchema.title && !subSchema.$ref) {
+                const realPath = subSchema.$resolvedRef || path;
                 // Try to get definition name if missing
                 const splitByDefinitions = path.includes('/components/schemas/')
-                    ? path.split('/components/schemas/')
-                    : path.split('/definitions/');
-                const maybeDefinitionBasedPath = splitByDefinitions.length > 1 ? splitByDefinitions[splitByDefinitions.length - 1] : path;
+                    ? realPath.split('/components/schemas/')
+                    : realPath.split('/definitions/');
+                const maybeDefinitionBasedPath = splitByDefinitions.length > 1 ? splitByDefinitions[splitByDefinitions.length - 1] : realPath;
                 let pathBasedName = maybeDefinitionBasedPath
                     .split('/properties')
                     .join('')
@@ -454,150 +603,6 @@ async function healJSONSchema(schema) {
     });
 }
 
-const resolvePath = (path, root) => {
-    return JsonPointer.get(root, path);
-};
-function isRefObject(obj) {
-    return typeof obj === 'object' && obj.$ref;
-}
-function isURL(str) {
-    return /^https?:\/\//.test(str);
-}
-const getAbsolute$Ref = (given$ref, baseFilePath) => {
-    const [givenExternalFileRelativePath, givenRefPath] = given$ref.split('#');
-    if (givenExternalFileRelativePath) {
-        const cwd = isURL(baseFilePath) ? getCwdForUrl(baseFilePath) : dirname(baseFilePath);
-        const givenExternalFilePath = getAbsolutePath(givenExternalFileRelativePath, cwd);
-        if (givenRefPath) {
-            return `${givenExternalFilePath}#${givenRefPath}`;
-        }
-        return givenExternalFilePath;
-    }
-    return `${baseFilePath}#${givenRefPath}`;
-};
-function getCwdForUrl(url) {
-    const urlParts = url.split('/');
-    urlParts.pop();
-    return urlParts.join('/');
-}
-function normalizeUrl(url) {
-    return new URL(url).toString();
-}
-function getAbsolutePath(path, cwd) {
-    if (isURL(path)) {
-        return path;
-    }
-    if (isURL(cwd)) {
-        return normalizeUrl(urlJoin(cwd, path));
-    }
-    if (isAbsolute(path)) {
-        return path;
-    }
-    return join(cwd, path);
-}
-function getCwd(path) {
-    return isURL(path) ? getCwdForUrl(path) : dirname(path);
-}
-// eslint-disable-next-line @typescript-eslint/ban-types
-async function dereferenceObject(obj, { cwd = process.cwd(), externalFileCache = new Map(), refMap = new Map(), root = obj, fetch: fetch$1 = fetch, headers, } = {}) {
-    if (typeof obj === 'object') {
-        if (isRefObject(obj)) {
-            const $ref = obj.$ref;
-            if (refMap.has($ref)) {
-                return refMap.get($ref);
-            }
-            else {
-                const [externalRelativeFilePath, refPath] = $ref.split('#');
-                if (externalRelativeFilePath) {
-                    const externalFilePath = getAbsolutePath(externalRelativeFilePath, cwd);
-                    const newCwd = getCwd(externalFilePath);
-                    let externalFile = externalFileCache.get(externalFilePath);
-                    if (!externalFile) {
-                        externalFile = await readFileOrUrl(externalFilePath, {
-                            fetch: fetch$1,
-                            headers,
-                            cwd,
-                        }).catch(() => {
-                            throw new Error(`Unable to load ${externalRelativeFilePath} from ${cwd}`);
-                        });
-                        externalFile = await healJSONSchema(externalFile);
-                        externalFileCache.set(externalFilePath, externalFile);
-                    }
-                    const result = await dereferenceObject(refPath
-                        ? {
-                            $ref: `#${refPath}`,
-                        }
-                        : externalFile, {
-                        cwd: newCwd,
-                        externalFileCache,
-                        refMap: new Proxy(refMap, {
-                            get: (originalRefMap, key) => {
-                                switch (key) {
-                                    case 'has':
-                                        return (given$ref) => {
-                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
-                                            return originalRefMap.has(original$Ref);
-                                        };
-                                    case 'get':
-                                        return (given$ref) => {
-                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
-                                            return originalRefMap.get(original$Ref);
-                                        };
-                                    case 'set':
-                                        return (given$ref, val) => {
-                                            const original$Ref = getAbsolute$Ref(given$ref, externalFilePath);
-                                            return originalRefMap.set(original$Ref, val);
-                                        };
-                                }
-                                throw new Error('Not implemented ' + key.toString());
-                            },
-                        }),
-                        fetch: fetch$1,
-                        headers,
-                        root: externalFile,
-                    });
-                    refMap.set($ref, result);
-                    return result;
-                }
-                else {
-                    const resolvedObj = resolvePath(refPath, root);
-                    if (typeof resolvedObj === 'object' && !resolvedObj.$ref) {
-                        refMap.set($ref, resolvedObj);
-                    }
-                    const result = await dereferenceObject(resolvedObj, {
-                        cwd,
-                        externalFileCache,
-                        refMap,
-                        root,
-                        fetch: fetch$1,
-                        headers,
-                    });
-                    if (!result.title && obj.title) {
-                        result.title = obj.title;
-                    }
-                    refMap.set($ref, result);
-                    return result;
-                }
-            }
-        }
-        else {
-            await Promise.all(Object.entries(obj).map(async ([key, val]) => {
-                if (typeof val === 'object') {
-                    obj[key] = await dereferenceObject(val, {
-                        cwd,
-                        externalFileCache,
-                        refMap,
-                        root,
-                        fetch: fetch$1,
-                        headers,
-                    });
-                }
-            }));
-        }
-    }
-    return obj;
-}
-
 async function referenceJSONSchema(schema) {
     const definitions = {};
     const finalSchema = await visitJSONSchema(schema, subSchema => {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "json-machete",
-  "version": "0.3.5",
+  "version": "0.3.6-alpha-983cd38bc.0",
   "sideEffects": false,
   "dependencies": {
     "@graphql-mesh/utils": "0.26.0",
     "@json-schema-tools/meta-schema": "1.6.19",
-    "cross-undici-fetch": "0.1.13",
+    "cross-undici-fetch": "0.1.15",
     "json-ptr": "3.0.1",
     "to-json-schema": "0.2.5",
     "url-join": "4.0.1"