@eventcatalog/core 4.10.15 → 4.11.1

package/eventcatalog/src/enterprise/fields/field-extractor.test.ts

@@ -1,302 +0,0 @@
-/**
- * Licensed under the EventCatalog Commercial License.
- * See /packages/core/eventcatalog/src/enterprise/LICENSE
- */
-
-import { describe, it, expect } from 'vitest';
-import { extractSchemaFieldsDeep } from './field-extractor';
-
-describe('extractSchemaFieldsDeep', () => {
-  describe('JSON Schema', () => {
-    it('extracts top-level properties with their types', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          orderId: { type: 'string', description: 'The order ID' },
-          amount: { type: 'number' },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields).toEqual([
-        { path: 'orderId', type: 'string', description: 'The order ID', required: false },
-        { path: 'amount', type: 'number', description: '', required: false },
-      ]);
-    });
-
-    it('marks fields as required when listed in the JSON Schema required array', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        required: ['orderId'],
-        properties: {
-          orderId: { type: 'string' },
-          notes: { type: 'string' },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields[0].required).toBe(true);
-      expect(fields[1].required).toBe(false);
-    });
-
-    it('extracts nested object fields with dot-notation paths', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          address: {
-            type: 'object',
-            properties: {
-              street: { type: 'string' },
-              city: { type: 'string' },
-            },
-          },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields.map((f) => f.path)).toEqual(['address', 'address.street', 'address.city']);
-    });
-
-    it('uses bracket notation for array item fields', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          items: {
-            type: 'array',
-            items: {
-              type: 'object',
-              properties: {
-                productId: { type: 'string' },
-                quantity: { type: 'integer' },
-              },
-            },
-          },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields.map((f) => f.path)).toEqual(['items', 'items[].productId', 'items[].quantity']);
-    });
-
-    it('resolves local $ref references within the same schema', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          billing: { $ref: '#/definitions/Address' },
-        },
-        definitions: {
-          Address: {
-            type: 'object',
-            properties: {
-              street: { type: 'string' },
-              zip: { type: 'string' },
-            },
-          },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields.map((f) => f.path)).toEqual(['billing', 'billing.street', 'billing.zip']);
-    });
-
-    it('skips external $ref references and returns only local fields', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          orderId: { type: 'string' },
-          customer: { $ref: './common.json#/definitions/Customer' },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields).toHaveLength(2);
-      expect(fields[0].path).toBe('orderId');
-      expect(fields[1].path).toBe('customer');
-      expect(fields[1].type).toBe('$ref');
-    });
-
-    it('merges allOf schemas and extracts combined properties', () => {
-      const schema = JSON.stringify({
-        allOf: [
-          { type: 'object', properties: { id: { type: 'string' } } },
-          { type: 'object', properties: { name: { type: 'string' } } },
-        ],
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields.map((f) => f.path)).toEqual(['id', 'name']);
-    });
-
-    it('converts array type values to a sorted pipe-separated string (e.g. nullable fields)', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          userId: { type: 'string', description: 'identifier for a user' },
-          cancellationReason: { type: ['string', 'null'], description: 'optional reason' },
-          renewalDate: { type: ['null', 'integer'], description: 'unix timestamp or null' },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields).toEqual([
-        { path: 'userId', type: 'string', description: 'identifier for a user', required: false },
-        { path: 'cancellationReason', type: 'null | string', description: 'optional reason', required: false },
-        { path: 'renewalDate', type: 'integer | null', description: 'unix timestamp or null', required: false },
-      ]);
-    });
-
-    it('recurses into nested properties when object type is nullable', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          metadata: {
-            type: ['object', 'null'],
-            properties: {
-              source: { type: 'string' },
-              version: { type: 'integer' },
-            },
-          },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields.map((f) => f.path)).toEqual(['metadata', 'metadata.source', 'metadata.version']);
-      expect(fields[0].type).toBe('null | object');
-    });
-
-    it('recurses into array items when array type is nullable', () => {
-      const schema = JSON.stringify({
-        type: 'object',
-        properties: {
-          tags: {
-            type: ['array', 'null'],
-            items: {
-              type: 'object',
-              properties: {
-                key: { type: 'string' },
-                value: { type: 'string' },
-              },
-            },
-          },
-        },
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'json-schema');
-      expect(fields.map((f) => f.path)).toEqual(['tags', 'tags[].key', 'tags[].value']);
-      expect(fields[0].type).toBe('array | null'); // already sorted alphabetically
-    });
-
-    it('returns empty array when schema content is malformed JSON', () => {
-      const fields = extractSchemaFieldsDeep('not valid json{{{', 'json-schema');
-      expect(fields).toEqual([]);
-    });
-
-    it('returns empty array when schema content is empty', () => {
-      const fields = extractSchemaFieldsDeep('', 'json-schema');
-      expect(fields).toEqual([]);
-    });
-  });
-
-  describe('Avro', () => {
-    it('extracts fields from a simple Avro record', () => {
-      const schema = JSON.stringify({
-        type: 'record',
-        name: 'Order',
-        fields: [
-          { name: 'orderId', type: 'string', doc: 'The order identifier' },
-          { name: 'amount', type: 'double' },
-        ],
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'avro');
-      expect(fields).toEqual([
-        { path: 'orderId', type: 'string', description: 'The order identifier', required: true },
-        { path: 'amount', type: 'double', description: '', required: true },
-      ]);
-    });
-
-    it('handles Avro union types containing null as optional fields', () => {
-      const schema = JSON.stringify({
-        type: 'record',
-        name: 'Customer',
-        fields: [
-          { name: 'id', type: 'string' },
-          { name: 'nickname', type: ['null', 'string'] },
-        ],
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'avro');
-      expect(fields[0].required).toBe(true);
-      expect(fields[1].required).toBe(false);
-      expect(fields[1].type).toBe('null | string');
-    });
-
-    it('extracts nested record fields with dot-notation paths', () => {
-      const schema = JSON.stringify({
-        type: 'record',
-        name: 'Order',
-        fields: [
-          {
-            name: 'customer',
-            type: {
-              type: 'record',
-              name: 'Customer',
-              fields: [
-                { name: 'name', type: 'string' },
-                { name: 'email', type: 'string' },
-              ],
-            },
-          },
-        ],
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'avro');
-      expect(fields.map((f) => f.path)).toEqual(['customer', 'customer.name', 'customer.email']);
-    });
-
-    it('uses bracket notation for Avro array items', () => {
-      const schema = JSON.stringify({
-        type: 'record',
-        name: 'Order',
-        fields: [
-          {
-            name: 'items',
-            type: {
-              type: 'array',
-              items: {
-                type: 'record',
-                name: 'Item',
-                fields: [
-                  { name: 'productId', type: 'string' },
-                  { name: 'qty', type: 'int' },
-                ],
-              },
-            },
-          },
-        ],
-      });
-      const fields = extractSchemaFieldsDeep(schema, 'avro');
-      expect(fields.map((f) => f.path)).toEqual(['items', 'items[].productId', 'items[].qty']);
-    });
-  });
-
-  describe('Protobuf', () => {
-    it('extracts fields from a simple proto3 message', () => {
-      const proto = `
-        syntax = "proto3";
-        message Order {
-          string order_id = 1;
-          double amount = 2; // total amount
-        }
-      `;
-      const fields = extractSchemaFieldsDeep(proto, 'proto');
-      expect(fields).toEqual([
-        { path: 'order_id', type: 'string', description: '', required: false },
-        { path: 'amount', type: 'double', description: 'total amount', required: false },
-      ]);
-    });
-
-    it('marks repeated fields with their modifier in the type', () => {
-      const proto = `
-        syntax = "proto3";
-        message Order {
-          repeated string tags = 1;
-        }
-      `;
-      const fields = extractSchemaFieldsDeep(proto, 'proto');
-      expect(fields[0].type).toBe('repeated string');
-    });
-
-    it('returns empty array for empty proto content', () => {
-      const fields = extractSchemaFieldsDeep('', 'proto');
-      expect(fields).toEqual([]);
-    });
-  });
-});

package/eventcatalog/src/enterprise/fields/fields-db.test.ts

@@ -1,185 +0,0 @@
-/**
- * Licensed under the EventCatalog Commercial License.
- * See /packages/core/eventcatalog/src/enterprise/LICENSE
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { FieldsDatabase } from './fields-db';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-
-describe('FieldsDatabase', () => {
-  let db: FieldsDatabase;
-  let tmpDir: string;
-
-  beforeEach(async () => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'fields-db-'));
-    db = await FieldsDatabase.create(path.join(tmpDir, 'fields.db'), { recreate: true });
-  });
-
-  afterEach(() => {
-    db.close();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('creates the schema tables on initialization', () => {
-    const rows = db.db.exec("SELECT name FROM sqlite_master WHERE type='table'");
-    const tableNames = rows.length > 0 ? rows[0].values.map((r: any) => r[0]) : [];
-    expect(tableNames).toContain('fields');
-    expect(tableNames).toContain('message_producers');
-    expect(tableNames).toContain('message_consumers');
-  });
-
-  it('inserts fields and retrieves them with pagination', () => {
-    db.insertField({
-      path: 'orderId',
-      type: 'string',
-      description: 'The order ID',
-      required: true,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    db.insertField({
-      path: 'amount',
-      type: 'number',
-      description: '',
-      required: false,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    const result = db.queryFields({});
-    expect(result.fields).toHaveLength(2);
-    expect(result.total).toBe(2);
-  });
-
-  it('filters fields by text search matching field path', () => {
-    db.insertField({
-      path: 'orderId',
-      type: 'string',
-      description: '',
-      required: true,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    db.insertField({
-      path: 'amount',
-      type: 'number',
-      description: '',
-      required: false,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    const result = db.queryFields({ q: 'orderId' });
-    expect(result.fields).toHaveLength(1);
-    expect(result.fields[0].path).toBe('orderId');
-  });
-
-  it('filters fields that appear in multiple messages when shared flag is set', () => {
-    db.insertField({
-      path: 'customerId',
-      type: 'string',
-      description: '',
-      required: true,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    db.insertField({
-      path: 'customerId',
-      type: 'string',
-      description: '',
-      required: true,
-      schemaFormat: 'json-schema',
-      messageId: 'PaymentProcessed',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    db.insertField({
-      path: 'amount',
-      type: 'number',
-      description: '',
-      required: false,
-      schemaFormat: 'json-schema',
-      messageId: 'PaymentProcessed',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    const result = db.queryFields({ shared: true });
-    expect(result.fields.every((f) => f.path === 'customerId')).toBe(true);
-  });
-
-  it('returns facet counts reflecting current filters', () => {
-    db.insertField({
-      path: 'orderId',
-      type: 'string',
-      description: '',
-      required: true,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    db.insertField({
-      path: 'status',
-      type: 'string',
-      description: '',
-      required: true,
-      schemaFormat: 'avro',
-      messageId: 'OrderUpdated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    const result = db.queryFields({});
-    expect(result.facets.formats).toContainEqual({ value: 'json-schema', count: 1 });
-    expect(result.facets.formats).toContainEqual({ value: 'avro', count: 1 });
-  });
-
-  it('paginates results using keyset cursor', () => {
-    for (let i = 0; i < 5; i++) {
-      db.insertField({
-        path: `field${i}`,
-        type: 'string',
-        description: '',
-        required: false,
-        schemaFormat: 'json-schema',
-        messageId: 'TestMsg',
-        messageVersion: '1.0.0',
-        messageType: 'event',
-      });
-    }
-    const page1 = db.queryFields({ pageSize: 2 });
-    expect(page1.fields).toHaveLength(2);
-    expect(page1.cursor).toBeDefined();
-    const page2 = db.queryFields({ pageSize: 2, cursor: page1.cursor });
-    expect(page2.fields).toHaveLength(2);
-    expect(page2.fields[0].path).not.toBe(page1.fields[0].path);
-  });
-
-  it('joins producer and consumer data for each field', () => {
-    db.insertField({
-      path: 'orderId',
-      type: 'string',
-      description: '',
-      required: true,
-      schemaFormat: 'json-schema',
-      messageId: 'OrderCreated',
-      messageVersion: '1.0.0',
-      messageType: 'event',
-    });
-    db.insertProducer('OrderCreated', '1.0.0', 'OrderService', '1.0.0');
-    db.insertConsumer('OrderCreated', '1.0.0', 'InventoryService', '2.0.0');
-    const result = db.queryFields({});
-    expect(result.fields[0].producers).toEqual([{ id: 'OrderService', version: '1.0.0' }]);
-    expect(result.fields[0].consumers).toEqual([{ id: 'InventoryService', version: '2.0.0' }]);
-  });
-});

package/eventcatalog/src/stores/eventcatalog-store.spec.ts

@@ -1,60 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { EventCatalogStore } from './eventcatalog-store';
-
-type TestStoreResources = {
-  users: { id: string; name: string }[];
-  teams: { id: string; name: string }[];
-};
-
-describe('EventCatalogStore', () => {
-  it('writes one collection while preserving the rest of the store', async () => {
-    const tempDir = await mkdtemp(path.join(tmpdir(), 'eventcatalog-store-'));
-    const storePath = EventCatalogStore.getStorePath(tempDir, 'directory');
-    const store = new EventCatalogStore<TestStoreResources>({
-      storePath,
-      resources: {
-        users: [],
-        teams: [],
-      },
-    });
-
-    try {
-      await store.writeCollection('teams', [{ id: 'platform', name: 'Platform' }]);
-      await store.writeCollection('users', [{ id: 'jane', name: 'Jane' }]);
-
-      const stored = JSON.parse(await readFile(storePath, 'utf8'));
-      expect(stored).toMatchObject({
-        version: '1',
-        resources: {
-          users: [{ id: 'jane', name: 'Jane' }],
-          teams: [{ id: 'platform', name: 'Platform' }],
-        },
-      });
-      expect(stored.generatedAt).toEqual(expect.any(String));
-    } finally {
-      await rm(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  it('does not create a store file when clearing a collection that has not been generated', async () => {
-    const tempDir = await mkdtemp(path.join(tmpdir(), 'eventcatalog-store-'));
-    const storePath = EventCatalogStore.getStorePath(tempDir, 'directory');
-    const store = new EventCatalogStore<TestStoreResources>({
-      storePath,
-      resources: {
-        users: [],
-        teams: [],
-      },
-    });
-
-    try {
-      await store.clearCollectionIfStoreExists('users');
-      expect(await store.exists()).toBe(false);
-    } finally {
-      await rm(tempDir, { recursive: true, force: true });
-    }
-  });
-});

package/eventcatalog/src/utils/collections/glob-loader.spec.ts

@@ -1,87 +0,0 @@
-import picomatch from 'picomatch';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { mkdtemp, mkdir, writeFile, symlink, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { globWithSafeWatcher, withFederatedContent, withIgnoredBuildArtifacts } from './glob-loader';
-
-describe('catalog discovery', () => {
-  const directories: string[] = [];
-
-  afterEach(async () => {
-    vi.unstubAllEnvs();
-    await Promise.all(directories.splice(0).map((directory) => rm(directory, { recursive: true, force: true })));
-  });
-
-  it.each([undefined, 'false', 'true'])('excludes dependency catalogs when IGNORE_BUILD_ARTIFACTS is %s', async (flag) => {
-    vi.stubEnv('IGNORE_BUILD_ARTIFACTS', flag);
-    const root = await mkdtemp(path.join(tmpdir(), 'catalog-discovery-'));
-    directories.push(root);
-    const catalog = path.join(root, 'catalog');
-    const resources = [
-      'events/OrderConfirmed/index.md',
-      'domains/Orders/services/Inventory/events/Adjusted/versioned/1.0.0/index.mdx',
-      'federated/orders/events/OrderConfirmed/index.mdx',
-    ];
-    const dependencies = [
-      'node_modules/core/src/__tests__/events/OrderConfirmed/index.md',
-      'node_modules/core/node_modules/sdk/events/OrderConfirmed/index.mdx',
-      'federated/orders/node_modules/sdk/events/OrderConfirmed/index.md',
-    ];
-    for (const entry of [...resources, ...dependencies]) {
-      const file = path.join(catalog, entry);
-      await mkdir(path.dirname(file), { recursive: true });
-      await writeFile(file, entry);
-    }
-    // Workspace dependencies are often symlinked outside the catalog.
-    const linkedPackage = path.join(root, 'linked-package');
-    await mkdir(path.join(linkedPackage, 'events/OrderConfirmed'), { recursive: true });
-    await writeFile(path.join(linkedPackage, 'events/OrderConfirmed/index.md'), 'dependency');
-    await symlink(linkedPackage, path.join(catalog, 'node_modules/linked'));
-
-    const loaded = new Map();
-    const logger = { warn: vi.fn(), error: vi.fn() };
-    const base = pathToFileURL(`${catalog}/`);
-    const loader = globWithSafeWatcher({
-      pattern: withIgnoredBuildArtifacts('**/events/**/index.(md|mdx)'),
-      base,
-      generateId: ({ entry }) => entry,
-    });
-    await loader.load({
-      config: { root: base, srcDir: new URL('src/', base) },
-      collection: 'events',
-      logger,
-      store: {
-        keys: () => loaded.keys(),
-        get: (id: string) => loaded.get(id),
-        set: (entry: { id: string }) => loaded.set(entry.id, entry),
-        delete: (id: string) => loaded.delete(id),
-      },
-      parseData: async ({ data }: { data: unknown }) => data,
-      generateDigest: (contents: string) => contents,
-      entryTypes: new Map(['.md', '.mdx'].map((ext) => [ext, { getEntryInfo: () => ({ data: {}, body: '' }) }])),
-    } as unknown as Parameters<typeof loader.load>[0]);
-
-    expect([...loaded.keys()].sort()).toEqual(resources.sort());
-    expect(logger.warn).not.toHaveBeenCalled();
-    expect(logger.error).not.toHaveBeenCalled();
-  });
-});
-
-describe('withFederatedContent', () => {
-  it('loads root catalog content from every federated source directory', () => {
-    const patterns = withFederatedContent(['services/*/index.(md|mdx)', 'domains/*/index.(md|mdx)', '!domains/*/services/**']);
-
-    expect(patterns).toEqual([
-      'services/*/index.(md|mdx)',
-      'domains/*/index.(md|mdx)',
-      '!domains/*/services/**',
-      'federated/*/services/*/index.(md|mdx)',
-      'federated/*/domains/*/index.(md|mdx)',
-      '!federated/*/domains/*/services/**',
-    ]);
-    expect(picomatch.isMatch('federated/team-payments--abc123/services/payment-service/index.mdx', patterns)).toBe(true);
-    expect(picomatch.isMatch('federated/team-payments--abc123/domains/payments/index.mdx', patterns)).toBe(true);
-  });
-});

package/dist/{chunk-6K7XZAYI.js → chunk-A2RZR3U4.js}

@@ -1,9 +1,9 @@
-import {
-  createGitHubSourceProvider
-} from "./chunk-352FGP6W.js";
 import {
   createFileSystemSourceProvider
 } from "./chunk-SDZQJTJW.js";
+import {
+  createGitHubSourceProvider
+} from "./chunk-352FGP6W.js";
 
 // src/federation/source-provider.ts
 var createFederationSourceProvider = (projectDirectory, providers = {}) => {