@stoplight/elements-core 9.0.25-beta-0.1 → 9.0.25-beta-0.2

package/src/utils/ref-resolving/resolvedObject.test.ts

@@ -0,0 +1,415 @@
+import { createResolvedObject, getOriginalObject } from './resolvedObject';
+
+describe('createResolvedObject', () => {
+  it('resolves a reference', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: 'parameterB value',
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB).toBe('parameterB value');
+  });
+
+  it('resolves a reference to an object', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: {
+          something: 'something else',
+        },
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB).toEqual({
+      something: 'something else',
+    });
+  });
+
+  it('resolves a circular reference', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        $ref: '#/bundled/paramaterA',
+      },
+      bundled: {
+        paramaterA: {
+          parameterB: {
+            $ref: '#/bundled/parameterB',
+          },
+          parameterC: 'parameterC value',
+        },
+        parameterB: {
+          paramaterA: {
+            $ref: '#/bundled/paramaterA',
+          },
+        },
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB.paramaterA.parameterB.paramaterA.parameterC).toBe(
+      'parameterC value',
+    );
+  });
+
+  it('resolves circular reference to the same value', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        $ref: '#/bundled/paramaterA',
+      },
+      bundled: {
+        paramaterA: {
+          parameterB: {
+            $ref: '#/bundled/parameterB',
+          },
+          parameterC: 'parameterC value',
+        },
+        parameterB: {
+          paramaterA: {
+            $ref: '#/bundled/paramaterA',
+          },
+        },
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB.paramaterA.parameterB.paramaterA).toBe(
+      (resolvedObject as any).paramaterA,
+    );
+  });
+
+  it('resolves deeply nested reference', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: {
+          parameterC: {
+            $ref: '#/bundled/parameterC',
+          },
+        },
+        parameterC: 'parameterC value',
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB.parameterC).toBe('parameterC value');
+  });
+
+  it('resolves references nested in arrays', () => {
+    const resolvedObject = createResolvedObject({
+      list: [
+        {
+          parameterB: {
+            $ref: '#/bundled/parameterB',
+          },
+        },
+      ],
+      bundled: {
+        parameterB: {
+          parameterC: {
+            $ref: '#/bundled/parameterC',
+          },
+        },
+        parameterC: 'parameterC value',
+      },
+    });
+
+    expect((resolvedObject as any).list[0].parameterB.parameterC).toBe('parameterC value');
+  });
+
+  it('returns the same object when accessing the parameter multiple times', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: 'parameterB value',
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA).toBe((resolvedObject as any).paramaterA);
+  });
+
+  it('returns the same object when called twice', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: 'parameterB value',
+      },
+    });
+
+    expect(createResolvedObject(resolvedObject)).toBe(resolvedObject);
+  });
+
+  it('allows to retrieve the original object', () => {
+    const originalObject = {
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: 'parameterB value',
+      },
+    };
+    const resolvedObject = createResolvedObject(originalObject);
+
+    expect(getOriginalObject((resolvedObject as any).paramaterA)).toBe(originalObject.paramaterA);
+  });
+
+  it('allows to customize resolution process', () => {
+    const originalObject = {
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+      bundled: {
+        parameterB: 'parameterB value',
+      },
+    };
+
+    const resolvedObject = createResolvedObject(originalObject, {
+      resolver: ({ pointer }, propertyPath, originalObject) => ({
+        pointer,
+        propertyPath,
+        originalObjectProperties: originalObject ? Object.keys(originalObject) : [],
+      }),
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB).toEqual({
+      pointer: '#/bundled/parameterB',
+      propertyPath: ['paramaterA', 'parameterB'],
+      originalObjectProperties: ['paramaterA', 'bundled'],
+    });
+  });
+
+  it('provides error message when resolving fails', () => {
+    const resolvedObject = createResolvedObject({
+      paramaterA: {
+        parameterB: {
+          $ref: '#/bundled/parameterB',
+        },
+      },
+    });
+
+    expect((resolvedObject as any).paramaterA.parameterB).toEqual({
+      $ref: '#/bundled/parameterB',
+      $error: "Could not resolve '#/bundled/parameterB'",
+    });
+  });
+
+  it('does not pass non-string references to resolver and ignores them', () => {
+    const originalObject = {
+      paramaterA: {
+        parameterB: {
+          $ref: {
+            not: 'a reference string',
+          },
+        },
+      },
+    };
+
+    const resolvedObject = createResolvedObject(originalObject, {
+      resolver: ({ pointer }) => {
+        if (typeof pointer !== 'string') {
+          throw new Error('Pointer should be a string!!!');
+        }
+      },
+    });
+
+    expect(resolvedObject).toEqual(originalObject);
+  });
+
+  // If the schema is internal, the object contains 'x-sl-error-message' on logout.
+  it('removes object if contains an error for oneOf', () => {
+    const originalObject = {
+      oneOf: [
+        { $ref: '#/__bundled__/0mui9s02880hl', 'x-stoplight': { id: '19c178fc05d4a' } },
+        {
+          'x-sl-error-message': 'You do not have permission to view this reference',
+          'x-stoplight': { 'error-message': 'You do not have permission to view this reference', id: 'nezai0hyj4yak' },
+        },
+        { $ref: '#/__bundled__/iq2mwk8jvthd2', 'x-stoplight': { id: 'ovj32wmpxpg7p' } },
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+
+    const filteredObject = {
+      oneOf: [
+        { $ref: '#/__bundled__/0mui9s02880hl', 'x-stoplight': { id: '19c178fc05d4a' } },
+        { $ref: '#/__bundled__/iq2mwk8jvthd2', 'x-stoplight': { id: 'ovj32wmpxpg7p' } },
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+    const resolvedObject = getOriginalObject(originalObject);
+
+    expect(resolvedObject).toEqual(filteredObject);
+  });
+
+  it('removes object if contains an error for anyeOf', () => {
+    const originalObject = {
+      anyOf: [
+        { $ref: '#/__bundled__/0mui9s02880hl', 'x-stoplight': { id: '19c178fc05d4a' } },
+        {
+          'x-sl-error-message': 'You do not have permission to view this reference',
+          'x-stoplight': { 'error-message': 'You do not have permission to view this reference', id: 'nezai0hyj4yak' },
+        },
+        { $ref: '#/__bundled__/iq2mwk8jvthd2', 'x-stoplight': { id: 'ovj32wmpxpg7p' } },
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+
+    const filteredObject = {
+      anyOf: [
+        { $ref: '#/__bundled__/0mui9s02880hl', 'x-stoplight': { id: '19c178fc05d4a' } },
+        { $ref: '#/__bundled__/iq2mwk8jvthd2', 'x-stoplight': { id: 'ovj32wmpxpg7p' } },
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+    const resolvedObject = getOriginalObject(originalObject);
+
+    expect(resolvedObject).toEqual(filteredObject);
+  });
+
+  it('show the error if all schemas are internal for anyOf', () => {
+    const originalObject = {
+      anyOf: [
+        [
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+        ],
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+
+    const filteredObject = {
+      anyOf: [
+        [
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+        ],
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+    const resolvedObject = getOriginalObject(originalObject);
+
+    expect(resolvedObject).toEqual(filteredObject);
+  });
+  it('show the error if all schemas are internal for oneOf', () => {
+    const originalObject = {
+      oneOf: [
+        [
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+        ],
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+
+    const filteredObject = {
+      oneOf: [
+        [
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+          {
+            'x-sl-error-message': 'You do not have permission to view this reference',
+            'x-stoplight': {
+              'error-message': 'You do not have permission to view this reference',
+              id: 'nezai0hyj4yak',
+            },
+          },
+        ],
+      ],
+      'x-stoplight': { id: 'b73ff5df9864f' },
+    };
+    const resolvedObject = getOriginalObject(originalObject);
+
+    expect(resolvedObject).toEqual(filteredObject);
+  });
+});

package/src/utils/ref-resolving/resolvedObject.ts

@@ -0,0 +1,189 @@
+import { hasRef } from '@stoplight/json';
+import { isArray, isPlainObject } from 'lodash';
+
+import { defaultResolver, ReferenceResolver } from './ReferenceResolver';
+
+const originalObjectSymbol = Symbol('OriginalObject');
+
+interface CreateResolvedObjectOptions {
+  contextObject?: object;
+  resolver?: ReferenceResolver;
+}
+
+export const createResolvedObject = (currentObject: object, options: CreateResolvedObjectOptions = {}): object =>
+  recursivelyCreateResolvedObject(currentObject, currentObject, [], new Map(), options);
+
+const recursivelyCreateResolvedObject = (
+  currentObject: object,
+  rootCurrentObject: object,
+  propertyPath: string[],
+  objectToProxiedObjectCache: Map<object, object>,
+  options: CreateResolvedObjectOptions = {},
+): object => {
+  if (isResolvedObjectProxy(currentObject)) return currentObject;
+
+  if (objectToProxiedObjectCache.has(currentObject)) return objectToProxiedObjectCache.get(currentObject)!;
+
+  const mergedOptions = {
+    contextObject: options.contextObject || currentObject,
+    resolver: options.resolver || defaultResolver(options.contextObject || currentObject),
+  };
+
+  const resolvedObjectProxy = new Proxy(currentObject, {
+    get(target: { [key: string | symbol]: unknown }, name) {
+      if (name === originalObjectSymbol) return currentObject;
+
+      const value = target[name];
+      const newPropertyPath = [...propertyPath, name.toString()];
+
+      let resolvedValue;
+      if (isReference(value)) {
+        try {
+          resolvedValue = mergedOptions.resolver(
+            { pointer: value.$ref, source: null },
+            newPropertyPath,
+            rootCurrentObject,
+          );
+        } catch (e) {
+          resolvedValue = {
+            ...value,
+            $error: e instanceof Error ? e.message : String(e),
+          };
+        }
+      } else {
+        resolvedValue = value;
+      }
+
+      if (isPlainObject(resolvedValue) || isArray(resolvedValue)) {
+        return recursivelyCreateResolvedObject(
+          resolvedValue,
+          rootCurrentObject,
+          newPropertyPath,
+          objectToProxiedObjectCache,
+          mergedOptions,
+        );
+      }
+
+      return resolvedValue;
+    },
+  });
+
+  objectToProxiedObjectCache.set(currentObject, resolvedObjectProxy);
+
+  return resolvedObjectProxy;
+};
+
+export const isResolvedObjectProxy = (someObject: object): boolean => {
+  return !!(someObject as Record<symbol, unknown>)[originalObjectSymbol];
+};
+
+// Resolves $refs by accessing properties through Proxy wrappers, ensuring nested references are resolved.
+export const getResolvedObject = (obj: any, cache = new WeakMap()): any => {
+  if (!isPlainObject(obj) && !isArray(obj)) {
+    return obj;
+  }
+
+  if (cache.has(obj)) {
+    return cache.get(obj);
+  }
+
+  if (isArray(obj)) {
+    const result: any[] = [];
+    cache.set(obj, result);
+    for (let i = 0; i < obj.length; i++) {
+      result[i] = getResolvedObject(obj[i], cache);
+    }
+    return result;
+  }
+
+  const result: any = {};
+  cache.set(obj, result);
+
+  for (const key in obj) {
+    if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+
+    const value = obj[key];
+
+    if (isArray(value)) {
+      result[key] = getResolvedObject(value, cache);
+    } else if (isPlainObject(value)) {
+      result[key] = getResolvedObject(value, cache);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};
+
+// Unwraps Proxy objects recursively, needed for oneOf/anyOf schemas with nested $refs.
+const deepUnwrapObject = (obj: any, cache = new WeakMap()): any => {
+  const unwrapped = (obj as Record<symbol, object>)?.[originalObjectSymbol] || obj;
+
+  if (!isPlainObject(unwrapped)) {
+    return unwrapped;
+  }
+
+  if (cache.has(obj)) {
+    return cache.get(obj);
+  }
+
+  const hasComposition =
+    Object.prototype.hasOwnProperty.call(unwrapped, 'oneOf') ||
+    Object.prototype.hasOwnProperty.call(unwrapped, 'anyOf') ||
+    Object.prototype.hasOwnProperty.call(unwrapped, 'allOf');
+
+  if (!hasComposition && unwrapped === obj) {
+    return unwrapped;
+  }
+
+  const result: any = {};
+  cache.set(obj, result);
+
+  for (const key in unwrapped) {
+    if (!Object.prototype.hasOwnProperty.call(unwrapped, key)) continue;
+
+    const value = (unwrapped as any)[key];
+
+    if (isArray(value)) {
+      result[key] = value.map(item => (isPlainObject(item) || isArray(item) ? deepUnwrapObject(item, cache) : item));
+    } else if (isPlainObject(value)) {
+      result[key] = deepUnwrapObject(value, cache);
+    } else {
+      result[key] = value;
+    }
+  }
+
+  return result;
+};
+
+export const getOriginalObject = (resolvedObject: object): object => {
+  const originalObject: any = (resolvedObject as Record<symbol, object>)[originalObjectSymbol] || resolvedObject;
+  if (!originalObject) {
+    return resolvedObject;
+  }
+
+  const hasAllSchemaErrors = (array: any[]) => {
+    return array.every(item => item['x-sl-error-message'] !== undefined);
+  };
+
+  const deepUnwrapped = deepUnwrapObject(originalObject);
+
+  if (deepUnwrapped.anyOf) {
+    if (hasAllSchemaErrors(deepUnwrapped.anyOf)) {
+      return { ...deepUnwrapped, anyOf: [deepUnwrapped.anyOf] };
+    }
+    const filteredArray = deepUnwrapped.anyOf.filter((item: { [x: string]: any }) => !item['x-sl-error-message']);
+    return { ...deepUnwrapped, anyOf: filteredArray };
+  } else if (deepUnwrapped.oneOf) {
+    if (hasAllSchemaErrors(deepUnwrapped.oneOf)) {
+      return { ...deepUnwrapped, oneOf: [deepUnwrapped.oneOf] };
+    }
+    const filteredArray = deepUnwrapped.oneOf.filter((item: { [x: string]: any }) => !item['x-sl-error-message']);
+    return { ...deepUnwrapped, oneOf: filteredArray };
+  }
+
+  return deepUnwrapped;
+};
+
+export const isReference = hasRef;