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

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

@@ -1,415 +0,0 @@
-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

@@ -1,189 +0,0 @@
-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;