@eventcatalog/core 4.10.15 → 4.11.1

package/eventcatalog/src/components/EnvironmentDropdown.test.ts

@@ -1,64 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildEnvironmentUrl, findCurrentEnvironment } from './EnvironmentDropdown';
-
-const environments = [
-  {
-    name: 'Development',
-    url: 'https://example.com/event-catalog/dev',
-    shortName: 'Dev',
-  },
-  {
-    name: 'UAT',
-    url: 'https://example.com/event-catalog/uat',
-    shortName: 'UAT',
-  },
-  {
-    name: 'Production',
-    url: 'https://example.com/event-catalog/prod',
-    shortName: 'Prod',
-  },
-];
-
-describe('EnvironmentDropdown', () => {
-  it('finds the current environment when environments share an origin but use different base paths', () => {
-    expect(findCurrentEnvironment(environments, 'https://example.com/event-catalog/uat/services/foo')?.name).toBe('UAT');
-  });
-
-  it('builds environment urls by replacing the current environment base path', () => {
-    expect(
-      buildEnvironmentUrl(
-        'https://example.com/event-catalog/prod',
-        'https://example.com/event-catalog/uat/services/foo',
-        'https://example.com/event-catalog/uat'
-      )
-    ).toBe('https://example.com/event-catalog/prod/services/foo');
-  });
-
-  it('preserves search params and hashes when switching environments', () => {
-    expect(
-      buildEnvironmentUrl(
-        'https://example.com/event-catalog/prod',
-        'https://example.com/event-catalog/uat/services/foo?tab=messages#latest',
-        'https://example.com/event-catalog/uat'
-      )
-    ).toBe('https://example.com/event-catalog/prod/services/foo?tab=messages#latest');
-  });
-
-  it('keeps existing origin based environment switching for root catalogs', () => {
-    expect(
-      buildEnvironmentUrl('https://prod.example.com', 'https://uat.example.com/services/foo', 'https://uat.example.com')
-    ).toBe('https://prod.example.com/services/foo');
-  });
-
-  it('switches from a root catalog to a subpath catalog', () => {
-    expect(buildEnvironmentUrl('https://example.com/prod', 'https://example.com/services/foo', 'https://example.com')).toBe(
-      'https://example.com/prod/services/foo'
-    );
-  });
-
-  it('preserves the current path when the current environment is unknown', () => {
-    expect(buildEnvironmentUrl('https://example.com/prod', 'http://localhost:3000/services/foo')).toBe(
-      'https://example.com/prod/services/foo'
-    );
-  });
-});

package/eventcatalog/src/components/Grids/message-link.spec.ts

@@ -1,59 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getMessageLinkProps } from './message-link';
-
-describe('getMessageLinkProps', () => {
-  it('builds a command docs url and prefers the resource name over the id', () => {
-    expect(
-      getMessageLinkProps({
-        collection: 'commands',
-        data: { id: 'order-create', name: 'Create Order', version: '0.0.1' },
-      })
-    ).toEqual({
-      collection: 'commands',
-      id: 'order-create',
-      name: 'Create Order',
-      version: '0.0.1',
-      href: '/docs/commands/order-create/0.0.1',
-    });
-  });
-
-  it('builds a query docs url from a hydrated collection entry', () => {
-    expect(
-      getMessageLinkProps({
-        collection: 'queries',
-        data: { id: 'get-stock-level', name: 'Get Stock Level', version: '1.0.0' },
-      })
-    ).toEqual({
-      collection: 'queries',
-      id: 'get-stock-level',
-      name: 'Get Stock Level',
-      version: '1.0.0',
-      href: '/docs/queries/get-stock-level/1.0.0',
-    });
-  });
-
-  it('does not default a missing collection to events', () => {
-    expect(getMessageLinkProps({ id: 'order-create', version: '0.0.1' })).toEqual({
-      collection: undefined,
-      id: 'order-create',
-      name: 'order-create',
-      version: '0.0.1',
-      href: undefined,
-    });
-  });
-
-  it('ignores unknown collection values instead of linking to events', () => {
-    expect(
-      getMessageLinkProps({
-        collection: 'services',
-        data: { id: 'order-service', name: 'Order Service', version: '1.0.0' },
-      })
-    ).toEqual({
-      collection: undefined,
-      id: 'order-service',
-      name: 'Order Service',
-      version: '1.0.0',
-      href: undefined,
-    });
-  });
-});

package/eventcatalog/src/components/MDX/CustomProperties/custom-properties.spec.ts

@@ -1,38 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { formatCustomPropertyLabel, getCustomProperties, getCustomProperty, isCustomPropertyName } from './custom-properties';
-
-describe('custom properties MDX components', () => {
-  it('recognizes extension property names', () => {
-    expect(isCustomPropertyName('x-owner')).toBe(true);
-    expect(isCustomPropertyName('x-')).toBe(false);
-    expect(isCustomPropertyName('owner')).toBe(false);
-  });
-
-  it('creates a readable label without changing uppercase text', () => {
-    expect(formatCustomPropertyLabel('x-operational-tier')).toBe('Operational Tier');
-    expect(formatCustomPropertyLabel('x-PII_classification')).toBe('PII Classification');
-  });
-
-  it('extracts only custom properties and preserves their values', () => {
-    const properties = getCustomProperties({
-      id: 'payment-api',
-      'x-operational-tier': 1,
-      'x-on-call': { schedule: 'payments-primary' },
-    });
-
-    expect(properties).toEqual([
-      { name: 'x-operational-tier', label: 'Operational Tier', value: 1 },
-      { name: 'x-on-call', label: 'On Call', value: { schedule: 'payments-primary' } },
-    ]);
-  });
-
-  it('gets a named custom property', () => {
-    expect(getCustomProperty({ 'x-owner': 'payments' }, 'x-owner')).toEqual({
-      name: 'x-owner',
-      label: 'Owner',
-      value: 'payments',
-    });
-    expect(getCustomProperty({ owner: 'payments' }, 'owner')).toBeUndefined();
-    expect(getCustomProperty({ 'x-owner': 'payments' }, 'x-missing')).toBeUndefined();
-  });
-});

package/eventcatalog/src/components/MDX/SchemaViewer/schema-viewer-utils.spec.ts

@@ -1,116 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveSchemaViewer } from './schema-viewer-utils';
-
-const currentMessageSchema = {
-  id: 'schema:events:OrderPlaced:1.0.0:git://contracts/events/OrderPlaced.schema.json',
-  data: {
-    ref: 'git://contracts/events/OrderPlaced.schema.json',
-    format: 'jsonschema',
-    content: '{"type":"object","title":"OrderPlaced"}',
-    default: true,
-    message: {
-      collectionName: 'events',
-      id: 'OrderPlaced',
-      version: '1.0.0',
-    },
-  },
-};
-
-describe('resolveSchemaViewer', () => {
-  it('uses the current message default schema when no file is set', async () => {
-    const schema = await resolveSchemaViewer({
-      id: 'OrderPlaced',
-      version: '1.0.0',
-      collection: 'events',
-      filePath: 'events/OrderPlaced/index.mdx',
-      schemaViewerProps: {},
-      collectionSchemas: [currentMessageSchema],
-      index: 0,
-    });
-
-    expect(schema.exists).toBe(true);
-    expect(schema.schema.title).toBe('OrderPlaced');
-    expect(schema.schemaPath).toBe('git://contracts/events/OrderPlaced.schema.json');
-  });
-
-  it('parses protobuf schemas from the schema collection', async () => {
-    const protoSchema = {
-      id: 'schema:events:FraudCheckCompleted:1.0.0:git://contracts/events/FraudCheckCompleted.proto',
-      data: {
-        ref: 'git://contracts/events/FraudCheckCompleted.proto',
-        format: 'protobuf',
-        content: 'syntax = "proto3";\nmessage FraudCheckCompleted {\n  string transaction_id = 1;\n}',
-        default: true,
-        message: {
-          collectionName: 'events',
-          id: 'FraudCheckCompleted',
-          version: '1.0.0',
-        },
-      },
-    };
-
-    const schema = await resolveSchemaViewer({
-      id: 'FraudCheckCompleted',
-      version: '1.0.0',
-      collection: 'events',
-      filePath: 'events/FraudCheckCompleted/index.mdx',
-      schemaViewerProps: {},
-      collectionSchemas: [protoSchema],
-      index: 0,
-    });
-
-    expect(schema.exists).toBe(true);
-    expect(schema.isProtobufSchema).toBe(true);
-    expect(schema.schema.syntax).toBe('proto3');
-    expect(schema.schema.messages[0].name).toBe('FraudCheckCompleted');
-    expect(schema.schema.messages[0].fields[0].name).toBe('transaction_id');
-  });
-
-  it('captures parse errors for invalid protobuf schemas', async () => {
-    const protoSchema = {
-      id: 'schema:events:FraudCheckCompleted:1.0.0:git://contracts/events/FraudCheckCompleted.proto',
-      data: {
-        ref: 'git://contracts/events/FraudCheckCompleted.proto',
-        format: 'protobuf',
-        content: '{"this": "is not protobuf"}',
-        default: true,
-        message: {
-          collectionName: 'events',
-          id: 'FraudCheckCompleted',
-          version: '1.0.0',
-        },
-      },
-    };
-
-    const schema = await resolveSchemaViewer({
-      id: 'FraudCheckCompleted',
-      version: '1.0.0',
-      collection: 'events',
-      filePath: 'events/FraudCheckCompleted/index.mdx',
-      schemaViewerProps: {},
-      collectionSchemas: [protoSchema],
-      index: 0,
-    });
-
-    expect(schema.exists).toBe(false);
-    expect(schema.parseError).toBeDefined();
-  });
-
-  it('does not use the schema collection when a file is set and missing', async () => {
-    const schema = await resolveSchemaViewer({
-      id: 'OrderPlaced',
-      version: '1.0.0',
-      collection: 'events',
-      filePath: 'events/OrderPlaced/index.mdx',
-      schemaViewerProps: {
-        file: 'missing-schema.json',
-      },
-      collectionSchemas: [currentMessageSchema],
-      index: 0,
-    });
-
-    expect(schema.exists).toBe(false);
-    expect(schema.schema).toBeUndefined();
-    expect(schema.schemaKey).toBe('missing-schema.json');
-  });
-});

package/eventcatalog/src/components/SchemaExplorer/JSONSchemaViewer.test.tsx

@@ -1,114 +0,0 @@
-// @vitest-environment jsdom
-import { act, createElement } from 'react';
-import { createRoot, type Root } from 'react-dom/client';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import JSONSchemaViewer from './JSONSchemaViewer';
-
-const constraintOnlyVariantSchema = {
-  type: 'object',
-  properties: {
-    detail: { $ref: '#/$defs/detail' },
-  },
-  $defs: {
-    detail: {
-      type: 'object',
-      properties: {
-        data: { $ref: '#/$defs/data' },
-      },
-    },
-    data: {
-      type: 'object',
-      properties: {
-        userId: { type: 'string' },
-        customerId: { type: 'string' },
-        correlationId: { type: 'string' },
-      },
-      required: ['correlationId'],
-      oneOf: [
-        {
-          title: 'Authenticated user',
-          required: ['userId'],
-          not: { required: ['customerId'] },
-        },
-        {
-          title: 'Customer account',
-          required: ['customerId'],
-          not: { required: ['userId'] },
-        },
-      ],
-    },
-  },
-};
-
-describe('JSONSchemaViewer variants', () => {
-  let container: HTMLDivElement;
-  let root: Root;
-
-  beforeEach(() => {
-    vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
-    container = document.createElement('div');
-    document.body.appendChild(container);
-    root = createRoot(container);
-  });
-
-  afterEach(() => {
-    act(() => root.unmount());
-    container.remove();
-    vi.unstubAllGlobals();
-  });
-
-  it('renders parent properties selected by constraint-only oneOf branches', () => {
-    act(() => {
-      root.render(createElement(JSONSchemaViewer, { schema: constraintOnlyVariantSchema, expand: true, search: false }));
-    });
-
-    expect(container.textContent).toContain('Authenticated user');
-    expect(container.textContent).toContain('userId');
-    expect(container.textContent).not.toContain('customerId');
-    expect(container.textContent).toContain('correlationId');
-
-    const selector = container.querySelector<HTMLSelectElement>('select');
-    expect(selector).not.toBeNull();
-
-    act(() => {
-      selector!.value = '1';
-      selector!.dispatchEvent(new Event('change', { bubbles: true }));
-    });
-
-    expect(container.textContent).toContain('customerId');
-    expect(container.textContent).not.toContain('userId');
-    expect(container.textContent).toContain('correlationId');
-  });
-
-  it('applies constraint-only oneOf branches at the schema root', () => {
-    const rootSchema = constraintOnlyVariantSchema.$defs.data;
-
-    act(() => {
-      root.render(createElement(JSONSchemaViewer, { schema: rootSchema, expand: true, search: false }));
-    });
-
-    expect(container.textContent).toContain('userId');
-    expect(container.textContent).not.toContain('customerId');
-    expect(container.textContent).toContain('correlationId');
-  });
-
-  it('does not render array item parent properties twice when variants are present', () => {
-    const arraySchema = {
-      type: 'object',
-      properties: {
-        identities: {
-          type: 'array',
-          items: constraintOnlyVariantSchema.$defs.data,
-        },
-      },
-    };
-
-    act(() => {
-      root.render(createElement(JSONSchemaViewer, { schema: arraySchema, expand: true, search: false }));
-    });
-
-    expect(container.textContent?.match(/userId/g)).toHaveLength(1);
-    expect(container.textContent).not.toContain('customerId');
-    expect(container.textContent?.match(/correlationId/g)).toHaveLength(1);
-  });
-});

package/eventcatalog/src/components/SchemaExplorer/ProtobufSchemaViewer.test.tsx

@@ -1,91 +0,0 @@
-import { renderToStaticMarkup } from 'react-dom/server';
-import { describe, expect, it } from 'vitest';
-import { parseProtobufSchema } from '@utils/protobuf-schema';
-import ProtobufSchemaViewer from './ProtobufSchemaViewer';
-
-describe('ProtobufSchemaViewer', () => {
-  it('renders Protovalidate required and constraint annotations', () => {
-    const schema = parseProtobufSchema(`
-      syntax = "proto3";
-
-      enum Status {
-        STATUS_UNSPECIFIED = 0;
-        STATUS_ACTIVE = 1;
-      }
-
-      message Journey {
-        string id = 1 [
-          (buf.validate.field).required = true,
-          (buf.validate.field).string.uuid = true
-        ];
-        uint32 passenger_count = 2 [(buf.validate.field).uint32 = { gte: 1, lte: 20 }];
-        Status status = 3 [(buf.validate.field).enum = { defined_only: true, not_in: [0] }];
-        repeated string stops = 4 [(buf.validate.field).repeated = {
-          min_items: 2
-          unique: true
-          items: { string: { min_len: 3 } }
-        }];
-        planning.model.v1.TrainServiceReference train_service = 5;
-        optional string description = 6 [(datahub.v1.gdpr_rule).string = true];
-      }
-    `);
-
-    const html = renderToStaticMarkup(<ProtobufSchemaViewer schema={schema} />);
-    const statusField = html.slice(html.indexOf('>status</span>'), html.indexOf('>stops</span>'));
-
-    expect(html).toContain('required');
-    expect(html).toContain('Format');
-    expect(html).toContain('UUID');
-    expect(html).toContain('Minimum');
-    expect(html).toContain('Maximum');
-    expect(html).toContain('Defined enum values only');
-    expect(html).toContain('Excluded values');
-    expect(html).toContain('Minimum items');
-    expect(html).toContain('Unique items');
-    expect(html).toContain('Item minimum length');
-    expect(html).toContain('title="planning.model.v1.TrainServiceReference"');
-    expect(html).toContain('>TrainServiceReference</span>');
-    expect(statusField).not.toContain('STATUS_UNSPECIFIED');
-    expect(statusField).toContain('STATUS_ACTIVE');
-    expect(html).toContain('Annotation:');
-    expect(html).toContain('(datahub.v1.gdpr_rule).string');
-    expect(html).toContain('>true</code>');
-  });
-
-  it('filters enum values using repeated-item and map-value constraints', () => {
-    const schema = parseProtobufSchema(`
-      syntax = "proto3";
-
-      enum Status {
-        STATUS_UNSPECIFIED = 0;
-        STATUS_ACTIVE = 1;
-        STATUS_ARCHIVED = 2;
-      }
-
-      message Journey {
-        repeated Status statuses = 1 [(buf.validate.field).repeated = {
-          items: { enum: { in: [1] } }
-        }];
-        map<string, Status> status_by_key = 2 [(buf.validate.field).map = {
-          values: { enum: { not_in: [0, 2] } }
-        }];
-        Status status = 3 [(buf.validate.field).enum.const = 2];
-      }
-    `);
-
-    const html = renderToStaticMarkup(<ProtobufSchemaViewer schema={schema} />);
-    const repeatedField = html.slice(html.indexOf('>statuses</span>'), html.indexOf('>status_by_key</span>'));
-    const mapField = html.slice(html.indexOf('>status_by_key</span>'), html.indexOf('>status</span>'));
-    const directField = html.slice(html.indexOf('>status</span>'), html.indexOf('>Enum:</span>'));
-
-    expect(repeatedField).toContain('STATUS_ACTIVE');
-    expect(repeatedField).not.toContain('STATUS_UNSPECIFIED');
-    expect(repeatedField).not.toContain('STATUS_ARCHIVED');
-    expect(mapField).toContain('STATUS_ACTIVE');
-    expect(mapField).not.toContain('STATUS_UNSPECIFIED');
-    expect(mapField).not.toContain('STATUS_ARCHIVED');
-    expect(directField).toContain('STATUS_ARCHIVED');
-    expect(directField).not.toContain('STATUS_UNSPECIFIED');
-    expect(directField).not.toContain('STATUS_ACTIVE');
-  });
-});

package/eventcatalog/src/components/SchemaExplorer/SchemaViewerHover.test.tsx

@@ -1,33 +0,0 @@
-import { renderToStaticMarkup } from 'react-dom/server';
-import { describe, expect, it } from 'vitest';
-import { parseProtobufSchema } from '@utils/protobuf-schema';
-import AvroSchemaViewer from './AvroSchemaViewer';
-import JSONSchemaViewer from './JSONSchemaViewer';
-import ProtobufSchemaViewer from './ProtobufSchemaViewer';
-
-const PROPERTY_HOVER_CLASS = 'hover:bg-[rgb(var(--ec-content-hover))]';
-
-describe('schema viewer property hover states', () => {
-  it('adds a hover background to JSON Schema properties', () => {
-    const html = renderToStaticMarkup(
-      <JSONSchemaViewer schema={{ type: 'object', properties: { id: { type: 'string' } } }} search={false} />
-    );
-
-    expect(html).toContain(PROPERTY_HOVER_CLASS);
-  });
-
-  it('adds a hover background to Avro fields', () => {
-    const html = renderToStaticMarkup(
-      <AvroSchemaViewer schema={{ type: 'record', name: 'Example', fields: [{ name: 'id', type: 'string' }] }} search={false} />
-    );
-
-    expect(html).toContain(PROPERTY_HOVER_CLASS);
-  });
-
-  it('adds a hover background to Protobuf fields', () => {
-    const schema = parseProtobufSchema('syntax = "proto3"; message Example { string id = 1; }');
-    const html = renderToStaticMarkup(<ProtobufSchemaViewer schema={schema} search={false} />);
-
-    expect(html).toContain(PROPERTY_HOVER_CLASS);
-  });
-});

package/eventcatalog/src/components/SchemaExplorer/protobuf-validation.test.ts

@@ -1,84 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import type { ProtobufField } from '@utils/protobuf-schema';
-import {
-  formatProtobufOptionValue,
-  formatProtovalidateRule,
-  getCustomFieldAnnotations,
-  getProtovalidateRules,
-  isProtovalidateRequired,
-} from './protobuf-validation';
-
-describe('protobuf validation helpers', () => {
-  it('flattens direct and aggregate Protovalidate options', () => {
-    const field: ProtobufField = {
-      name: 'status',
-      type: 'Status',
-      options: [
-        { name: '(buf.validate.field).required', value: true },
-        {
-          name: '(buf.validate.field).enum',
-          value: { defined_only: true, not_in: [0] },
-        },
-      ],
-    };
-
-    expect(getProtovalidateRules(field)).toEqual([
-      { path: 'required', value: true },
-      { path: 'enum.defined_only', value: true },
-      { path: 'enum.not_in', value: [0] },
-    ]);
-    expect(isProtovalidateRequired(field)).toBe(true);
-  });
-
-  it('ignores non-Protovalidate custom options', () => {
-    const field: ProtobufField = {
-      name: 'description',
-      type: 'string',
-      options: [{ name: '(datahub.v1.gdpr_rule).string', value: true }],
-    };
-
-    expect(getProtovalidateRules(field)).toEqual([]);
-    expect(isProtovalidateRequired(field)).toBe(false);
-    expect(getCustomFieldAnnotations(field)).toEqual([{ name: '(datahub.v1.gdpr_rule).string', value: true }]);
-  });
-
-  it('only treats extension options as custom annotations and formats aggregate values', () => {
-    const field: ProtobufField = {
-      name: 'description',
-      type: 'string',
-      options: [
-        { name: 'deprecated', value: true },
-        { name: '(buf.validate.field).string.min_len', value: 1 },
-        { name: '(datahub.v1.classification)', value: { level: 'personal', encrypted: true } },
-      ],
-    };
-
-    expect(getCustomFieldAnnotations(field)).toEqual([
-      {
-        name: '(datahub.v1.classification)',
-        value: { level: 'personal', encrypted: true },
-      },
-    ]);
-    expect(formatProtobufOptionValue(getCustomFieldAnnotations(field)[0].value)).toBe('{"level":"personal","encrypted":true}');
-  });
-
-  it('formats common rules for display', () => {
-    expect(formatProtovalidateRule({ path: 'string.email', value: true })).toEqual({ label: 'Format', value: 'Email' });
-    expect(formatProtovalidateRule({ path: 'uint32.gte', value: 1 })).toEqual({ label: 'Minimum', value: '1' });
-    expect(formatProtovalidateRule({ path: 'enum.defined_only', value: true })).toEqual({
-      label: 'Defined enum values only',
-    });
-    expect(formatProtovalidateRule({ path: 'enum.not_in', value: [0] })).toEqual({
-      label: 'Excluded values',
-      value: '0',
-    });
-    expect(formatProtovalidateRule({ path: 'repeated.items.string.min_len', value: 3 })).toEqual({
-      label: 'Item minimum length',
-      value: '3',
-    });
-    expect(formatProtovalidateRule({ path: 'map.values.string.max_len', value: 100 })).toEqual({
-      label: 'Value maximum length',
-      value: '100',
-    });
-  });
-});