@stoplight/elements-core 9.0.16-beta-0.3 → 9.0.17

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,107 +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];
-};
-
-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);
-  };
-
-  if (originalObject.anyOf) {
-    if (hasAllSchemaErrors(originalObject.anyOf)) {
-      return { ...originalObject, anyOf: [originalObject.anyOf] };
-    }
-    const filteredArray = originalObject.anyOf.filter((item: { [x: string]: any }) => !item['x-sl-error-message']);
-    return { ...originalObject, anyOf: filteredArray };
-  } else if (originalObject.oneOf) {
-    if (hasAllSchemaErrors(originalObject.oneOf)) {
-      return { ...originalObject, oneOf: [originalObject.oneOf] };
-    }
-    const filteredArray = originalObject.oneOf.filter((item: { [x: string]: any }) => !item['x-sl-error-message']);
-    return { ...originalObject, oneOf: filteredArray };
-  }
-
-  return originalObject;
-};
-
-export const isReference = hasRef;

package/src/utils/securitySchemes.ts

@@ -1,117 +0,0 @@
-import {
-  HttpSecurityScheme,
-  IApiKeySecurityScheme,
-  IBasicSecurityScheme,
-  IBearerSecurityScheme,
-  IOauth2Flow,
-  IOauth2SecurityScheme,
-  IOauthFlowObjects,
-} from '@stoplight/types';
-import { entries, keys } from 'lodash';
-
-import {
-  isOauth2AuthorizationCodeFlow,
-  isOauth2ClientCredentialsOrPasswordFlow,
-  isOAuth2ImplicitFlow,
-} from './oas/security';
-
-const oauthFlowNames: Record<keyof IOauthFlowObjects, string> = {
-  implicit: 'Implicit',
-  authorizationCode: 'Authorization Code',
-  clientCredentials: 'Client Credentials',
-  password: 'Password',
-};
-
-export function getDefaultDescription(scheme: HttpSecurityScheme) {
-  switch (scheme.type) {
-    case 'apiKey':
-      return getApiKeyDescription(scheme);
-    case 'http':
-      switch (scheme.scheme) {
-        case 'basic':
-          return getBasicAuthDescription(scheme);
-        case 'bearer':
-          return getBearerAuthDescription(scheme);
-        case 'digest':
-          return getDigestAuthDescription(scheme);
-      }
-    case 'oauth2':
-      return getOAuthDescription(scheme);
-  }
-
-  return '';
-}
-
-export function getOptionalAuthDescription() {
-  return `Providing Auth is optional; requests may be made without an included Authorization header.`;
-}
-
-function getApiKeyDescription(scheme: IApiKeySecurityScheme) {
-  const { in: inProperty, name } = scheme;
-  return `An API key is a token that you provide when making API calls. Include the token in a ${inProperty} parameter called \`${name}\`.
-
-  Example: ${inProperty === 'query' ? `\`?${name}=123\`` : `\`${name}: 123\``}${getSecuritySchemeRoles(scheme)}`;
-}
-
-function getBasicAuthDescription(schema: IBasicSecurityScheme) {
-  return `Basic authentication is a simple authentication scheme built into the HTTP protocol.
-  To use it, send your HTTP requests with an Authorization header that contains the word Basic
-  followed by a space and a base64-encoded string \`username:password\`.
-
-  Example: \`Authorization: Basic ZGVtbzpwQDU1dzByZA==\`${getSecuritySchemeRoles(schema)}`;
-}
-
-function getBearerAuthDescription(schema: IBearerSecurityScheme) {
-  return `Provide your bearer token in the Authorization header when making requests to protected resources.
-
-  Example: \`Authorization: Bearer 123\`${getSecuritySchemeRoles(schema)}`;
-}
-
-function getDigestAuthDescription(schema: IBasicSecurityScheme) {
-  return `Provide your encrypted digest scheme data in the Authorization header when making requests to protected resources.
-
-  Example: \`Authorization: Digest username=guest, realm="test", nonce="2", uri="/uri", response="123"\`${getSecuritySchemeRoles(
-    schema,
-  )}`;
-}
-
-function getOAuthDescription(scheme: IOauth2SecurityScheme) {
-  const flows = keys(scheme.flows);
-  return flows
-    .map(flow =>
-      getOAuthFlowDescription(
-        oauthFlowNames[flow as keyof typeof oauthFlowNames],
-        scheme.flows[flow as keyof IOauthFlowObjects]!,
-      ),
-    )
-    .join('\n\n');
-}
-
-function getOAuthFlowDescription(title: string, flow: IOauth2Flow) {
-  let description = `**${title} OAuth Flow**`;
-
-  description +=
-    isOAuth2ImplicitFlow(flow) || isOauth2AuthorizationCodeFlow(flow)
-      ? `\n\nAuthorize URL: ${flow.authorizationUrl}`
-      : '';
-
-  description +=
-    isOauth2AuthorizationCodeFlow(flow) || isOauth2ClientCredentialsOrPasswordFlow(flow)
-      ? `\n\nToken URL: ${flow.tokenUrl}`
-      : '';
-
-  description += flow.refreshUrl ? `\n\nRefresh URL: ${flow.refreshUrl}` : '';
-
-  const scopes = entries(flow.scopes);
-  if (scopes.length) {
-    description += `\n\nScopes:
-${scopes.map(([key, value]) => `- \`${key}\` - ${value}`).join('\n')}`;
-  }
-
-  return description;
-}
-
-function getSecuritySchemeRoles(scheme: HttpSecurityScheme) {
-  const scopes = scheme.extensions?.['x-scopes'];
-  return Array.isArray(scopes) ? `\n\nRoles: ${scopes.map(scope => `\`${scope}\``).join(', ')}` : '';
-}

package/src/utils/string.ts

@@ -1,15 +0,0 @@
-import { curry } from 'lodash';
-
-export const caseInsensitivelyEquals = curry((a: string, b: string) => a.toUpperCase() === b.toUpperCase());
-
-export function slugify(name: string) {
-  return name
-    .replace(/\/|{|}|\s/g, '-')
-    .replace(/-{2,}/, '-')
-    .replace(/^-/, '')
-    .replace(/-$/, '');
-}
-
-export const resolveRelativeLink = (slug?: string) => {
-  return slug ? slug.replace(/^\//, '') : '.';
-};

package/src/utils/tests/chooseOption.ts

@@ -1,7 +0,0 @@
-import { screen } from '@testing-library/dom';
-import userEvent, { TargetElement } from '@testing-library/user-event';
-
-export function chooseOption(select: TargetElement, option: string) {
-  userEvent.click(select);
-  userEvent.selectOptions(screen.getByRole('listbox'), screen.getByRole('option', { name: option }));
-}