@transitrix/diagrams 1.8.6 → 1.8.8

package/src/blocks/__tests__/layout.test.ts

@@ -1,169 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutNestedBlocks, iterateBlocks } from '../layout.js';
-import type { BlocksFile, LaidOutBlock } from '../types.js';
-
-function findById(layout: ReturnType<typeof layoutNestedBlocks>, id: string): LaidOutBlock | undefined {
-  for (const b of iterateBlocks(layout)) {
-    if (b.id === id) return b;
-  }
-  return undefined;
-}
-
-const TWO_TOP_LEVEL: BlocksFile = {
-  notation: 'blocks',
-  spec_version: '0.1',
-  nested_blocks: {
-    id: 'BLOCKS-ARCH-1',
-    name: 'Software architecture',
-    blocks: [
-      {
-        id: 'APPLICATION_LAYER',
-        name: 'Application Layer',
-        children: [
-          {
-            id: 'FRONTEND',
-            name: 'Frontend',
-            children: [
-              { id: 'REACT_APP', name: 'React App' },
-              { id: 'REDUX_STORE', name: 'Redux Store' },
-            ],
-          },
-          {
-            id: 'BACKEND',
-            name: 'Backend',
-            children: [
-              { id: 'REST_API', name: 'REST API' },
-              { id: 'BUSINESS_LOGIC', name: 'Business Logic' },
-            ],
-          },
-        ],
-      },
-      {
-        id: 'DATA_LAYER',
-        name: 'Data Layer',
-        children: [
-          { id: 'POSTGRESQL', name: 'PostgreSQL' },
-          { id: 'REDIS_CACHE', name: 'Redis Cache' },
-        ],
-      },
-    ],
-  },
-};
-
-describe('layoutNestedBlocks', () => {
-  it('lays out top-level blocks vertically starting at y=0', () => {
-    const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
-    expect(layout.blocks).toHaveLength(2);
-    expect(layout.blocks[0].y).toBe(0);
-    expect(layout.blocks[1].y).toBeGreaterThan(layout.blocks[0].y + layout.blocks[0].height);
-  });
-
-  it('assigns depth=1 to top-level blocks and increases for each nesting level', () => {
-    const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
-    const app = findById(layout, 'APPLICATION_LAYER')!;
-    const frontend = findById(layout, 'FRONTEND')!;
-    const react = findById(layout, 'REACT_APP')!;
-    expect(app.depth).toBe(1);
-    expect(frontend.depth).toBe(2);
-    expect(react.depth).toBe(3);
-  });
-
-  it('records max depth on the layout', () => {
-    const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
-    expect(layout.maxDepth).toBe(3);
-  });
-
-  it('places every child strictly inside its parent (containment property)', () => {
-    const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
-
-    function checkContainment(b: LaidOutBlock): void {
-      for (const c of b.children) {
-        expect(c.x).toBeGreaterThanOrEqual(b.x);
-        expect(c.y).toBeGreaterThanOrEqual(b.y + b.headerHeight);
-        expect(c.x + c.width).toBeLessThanOrEqual(b.x + b.width);
-        expect(c.y + c.height).toBeLessThanOrEqual(b.y + b.height);
-        checkContainment(c);
-      }
-    }
-
-    for (const top of layout.blocks) checkContainment(top);
-  });
-
-  it('siblings do not overlap', () => {
-    const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
-
-    function checkSiblings(b: LaidOutBlock): void {
-      for (let i = 0; i < b.children.length; i++) {
-        for (let j = i + 1; j < b.children.length; j++) {
-          const a = b.children[i];
-          const c = b.children[j];
-          const disjointX = a.x + a.width <= c.x || c.x + c.width <= a.x;
-          const disjointY = a.y + a.height <= c.y || c.y + c.height <= a.y;
-          expect(disjointX || disjointY).toBe(true);
-        }
-        checkSiblings(b.children[i]);
-      }
-    }
-
-    for (const top of layout.blocks) checkSiblings(top);
-  });
-
-  it('a leaf block uses the configured leaf dimensions', () => {
-    const layout = layoutNestedBlocks({
-      notation: 'blocks',
-      nested_blocks: {
-        id: 'BLOCKS-LEAF-1',
-        name: 'Leaf only',
-        blocks: [{ id: 'A', name: 'A' }],
-      },
-    });
-    const a = layout.blocks[0];
-    expect(a.width).toBe(250);
-    expect(a.height).toBe(80);
-  });
-
-  it('honours custom layout options', () => {
-    const layout = layoutNestedBlocks(
-      {
-        notation: 'blocks',
-        nested_blocks: {
-          id: 'BLOCKS-LEAF-1',
-          name: 'Leaf only',
-          blocks: [{ id: 'A', name: 'A' }],
-        },
-      },
-      { leafWidth: 200, leafHeight: 80 },
-    );
-    expect(layout.blocks[0].width).toBe(200);
-    expect(layout.blocks[0].height).toBe(80);
-  });
-
-  it('iterateBlocks visits every block once in pre-order', () => {
-    const layout = layoutNestedBlocks(TWO_TOP_LEVEL);
-    const ids = Array.from(iterateBlocks(layout)).map((b) => b.id);
-    expect(ids).toEqual([
-      'APPLICATION_LAYER',
-      'FRONTEND',
-      'REACT_APP',
-      'REDUX_STORE',
-      'BACKEND',
-      'REST_API',
-      'BUSINESS_LOGIC',
-      'DATA_LAYER',
-      'POSTGRESQL',
-      'REDIS_CACHE',
-    ]);
-  });
-
-  it('handles an empty top-level array gracefully (returns zero-size bounds)', () => {
-    const layout = layoutNestedBlocks({
-      notation: 'blocks',
-      // Schema-wise this is invalid (BL-004), but the layout function still
-      // needs to be defensive — validation runs separately.
-      nested_blocks: { id: 'X', name: 'X', blocks: [] },
-    });
-    expect(layout.blocks).toHaveLength(0);
-    expect(layout.bounds.width).toBe(0);
-    expect(layout.bounds.height).toBe(0);
-  });
-});

package/src/blocks/__tests__/validate.test.ts

@@ -1,260 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import yaml from 'js-yaml';
-import { validateNestedBlocks } from '../validate.js';
-
-const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'blocks');
-
-const VALID_DOC = {
-  notation: 'blocks',
-  spec_version: '0.1',
-  nested_blocks: {
-    id: 'BLOCKS-ARCH-1',
-    name: 'Software architecture',
-    blocks: [
-      {
-        id: 'APPLICATION_LAYER',
-        name: 'Application Layer',
-        children: [
-          { id: 'FRONTEND', name: 'Frontend' },
-          { id: 'BACKEND', name: 'Backend' },
-        ],
-      },
-      {
-        id: 'DATA_LAYER',
-        name: 'Data Layer',
-        children: [
-          { id: 'POSTGRESQL', name: 'PostgreSQL' },
-          { id: 'REDIS_CACHE', name: 'Redis Cache' },
-        ],
-      },
-    ],
-  },
-};
-
-describe('validateNestedBlocks', () => {
-  it('passes on a valid document', () => {
-    const r = validateNestedBlocks(VALID_DOC);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toHaveLength(0);
-  });
-
-  it('BL-001: rejects non-object input', () => {
-    expect(validateNestedBlocks(null).valid).toBe(false);
-    expect(validateNestedBlocks(null).errors[0].code).toBe('BL-001');
-    expect(validateNestedBlocks('string').errors[0].code).toBe('BL-001');
-  });
-
-  it('BL-001: rejects missing nested_blocks root key', () => {
-    const r = validateNestedBlocks({ notation: 'blocks' });
-    expect(r.errors.some((e) => e.code === 'BL-001')).toBe(true);
-  });
-
-  it('BL-001: rejects wrong notation value', () => {
-    const r = validateNestedBlocks({ ...VALID_DOC, notation: 'goals' });
-    expect(r.errors.some((e) => e.code === 'BL-001')).toBe(true);
-  });
-
-  it('BL-001: tolerates a missing notation field (header check is contract-level)', () => {
-    const { notation: _, ...rest } = VALID_DOC;
-    const r = validateNestedBlocks(rest);
-    expect(r.errors.some((e) => e.code === 'BL-001')).toBe(false);
-  });
-
-  it('BL-002: rejects missing id', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: { ...VALID_DOC.nested_blocks, id: '' },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-002')).toBe(true);
-  });
-
-  it('BL-002: rejects id that does not match BLOCKS grammar', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: { ...VALID_DOC.nested_blocks, id: 'BLK-1' },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-002')).toBe(true);
-  });
-
-  it('BL-003: rejects missing name', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: { ...VALID_DOC.nested_blocks, name: '' },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-003')).toBe(true);
-  });
-
-  it('BL-004: rejects missing blocks array', () => {
-    const { blocks: _, ...rest } = VALID_DOC.nested_blocks;
-    const r = validateNestedBlocks({ ...VALID_DOC, nested_blocks: rest });
-    expect(r.errors.some((e) => e.code === 'BL-004')).toBe(true);
-  });
-
-  it('BL-004: rejects empty blocks array', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: { ...VALID_DOC.nested_blocks, blocks: [] },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-004')).toBe(true);
-  });
-
-  it('BL-005: rejects block missing id', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ name: 'Anonymous' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-005' && /id/.test(e.message))).toBe(true);
-  });
-
-  it('BL-005: rejects block missing name', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ id: 'X', name: '' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-005' && /name/.test(e.message))).toBe(true);
-  });
-
-  it('BL-005: rejects an id with whitespace (not a valid free label)', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ id: 'bad id', name: 'X' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-005' && /whitespace/.test(e.message))).toBe(true);
-  });
-
-  it('BL-006: rejects a canonical-shaped id whose TYPE is not registered', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ id: 'XYZ-SOMETHING-1', name: 'X' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-006')).toBe(true);
-  });
-
-  it('BL-006: accepts canonical ids with registered TYPE (APPLICATION-OMS-1)', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ id: 'APPLICATION-OMS-1', name: 'OMS' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-006')).toBe(false);
-  });
-
-  it('BL-006: accepts the CAPABILITY V/H exception (CAPABILITY-V1.2)', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ id: 'CAPABILITY-V1.2', name: 'Order intake' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-006')).toBe(false);
-  });
-
-  it('BL-006: accepts free-form local labels (APPLICATION_LAYER, frontend, my-thing)', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [
-          { id: 'APPLICATION_LAYER', name: 'AL' },
-          { id: 'my-thing', name: 'MT' },
-          { id: 'FRONTEND', name: 'FE' },
-        ],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-006')).toBe(false);
-  });
-
-  it('BL-007: rejects duplicate ids anywhere in the tree', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [
-          {
-            id: 'A',
-            name: 'A',
-            children: [{ id: 'A', name: 'A again' }],
-          },
-        ],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'BL-007' && /Duplicate/.test(e.message))).toBe(true);
-  });
-
-  it('BL-008: warns when nesting exceeds depth 5', () => {
-    // 6-deep chain: blocks[0] (depth 1) → c → c → c → c → c (depth 6)
-    let inner: Record<string, unknown> = { id: 'L6', name: 'L6' };
-    for (const id of ['L5', 'L4', 'L3', 'L2', 'L1']) {
-      inner = { id, name: id, children: [inner] };
-    }
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: { ...VALID_DOC.nested_blocks, blocks: [inner] },
-    });
-    expect(r.warnings.some((w) => w.code === 'BL-008')).toBe(true);
-    expect(r.valid).toBe(true);
-  });
-
-  it('BL-008: does not warn at exactly depth 5', () => {
-    let inner: Record<string, unknown> = { id: 'L5', name: 'L5' };
-    for (const id of ['L4', 'L3', 'L2', 'L1']) {
-      inner = { id, name: id, children: [inner] };
-    }
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: { ...VALID_DOC.nested_blocks, blocks: [inner] },
-    });
-    expect(r.warnings.some((w) => w.code === 'BL-008')).toBe(false);
-  });
-
-  it('BL-009: warns on an empty children array', () => {
-    const r = validateNestedBlocks({
-      ...VALID_DOC,
-      nested_blocks: {
-        ...VALID_DOC.nested_blocks,
-        blocks: [{ id: 'A', name: 'A', children: [] }],
-      },
-    });
-    expect(r.warnings.some((w) => w.code === 'BL-009')).toBe(true);
-    expect(r.valid).toBe(true);
-  });
-
-  it('happy path: surfaces no warnings on a clean document', () => {
-    const r = validateNestedBlocks(VALID_DOC);
-    expect(r.valid).toBe(true);
-    expect(r.warnings).toHaveLength(0);
-  });
-});
-
-describe('blocks examples (regression)', () => {
-  const files = fs.existsSync(EXAMPLES_DIR)
-    ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.yaml'))
-    : [];
-  expect(files.length).toBeGreaterThan(0);
-  for (const file of files) {
-    it(`validates tests/fixtures/notation-corpus/blocks/${file}`, () => {
-      const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-      const parsed = yaml.load(text);
-      const r = validateNestedBlocks(parsed);
-      expect(r.errors).toEqual([]);
-      expect(r.valid).toBe(true);
-    });
-  }
-});

package/src/business-service/__tests__/validate.test.ts

@@ -1,160 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateBusinessService } from '../validate.js';
-
-function valid(): Record<string, unknown> {
-  return {
-    notation: 'business-service',
-    id: 'BUSINESS_SERVICE-CRM-1',
-    name: 'CRM Service',
-    type: 'internal',
-    description: 'Customer relationship management service offering contact management and deal tracking.',
-    offering_unit: 'ACTOR-SALES-OPS-1',
-    capability: 'CAPABILITY-V2.1',
-    zone: 'canon',
-    admitted_at: '2026-06-28',
-    admitted_by: 'v.korobeinikov',
-    gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-    valid_from: '2024-01-01',
-    valid_to: null,
-  };
-}
-
-const codes = (input: unknown): string[] =>
-  validateBusinessService(input).errors.map(e => e.code);
-
-describe('validateBusinessService — positive', () => {
-  it('accepts a well-formed internal service with all optional fields', () => {
-    const r = validateBusinessService(valid());
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-  });
-
-  it('accepts an external service with no optional fields', () => {
-    const a = valid();
-    a.id = 'BUSINESS_SERVICE-ONBOARDING-1';
-    a.name = 'Onboarding Service';
-    a.type = 'external';
-    delete a.description;
-    delete a.offering_unit;
-    delete a.capability;
-    expect(validateBusinessService(a).valid).toBe(true);
-  });
-
-  it('accepts a shared service offered by a ROLE', () => {
-    expect(validateBusinessService({ ...valid(), type: 'shared', offering_unit: 'ROLE-PLATFORM-OWNER-1' }).valid).toBe(true);
-  });
-
-  it('accepts valid_to as a date string', () => {
-    expect(validateBusinessService({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
-  });
-
-  it('accepts a service with no offering_unit or capability', () => {
-    const a = valid();
-    delete a.offering_unit;
-    delete a.capability;
-    expect(validateBusinessService(a).valid).toBe(true);
-  });
-});
-
-describe('validateBusinessService — BSV-001 (shape / id grammar)', () => {
-  it('flags a missing required envelope field (name)', () => {
-    const a = valid();
-    delete a.name;
-    expect(codes(a)).toContain('BSV-001');
-  });
-
-  it('flags an id that violates the grammar', () => {
-    expect(codes({ ...valid(), id: 'BUSINESS_SERVICE-001' })).toContain('BSV-001');
-    expect(codes({ ...valid(), id: 'BSV-1' })).toContain('BSV-001');
-    expect(codes({ ...valid(), id: 'business-service-1' })).toContain('BSV-001');
-  });
-
-  it('flags a wrong notation tag', () => {
-    expect(codes({ ...valid(), notation: 'service' })).toContain('BSV-001');
-    expect(codes({ ...valid(), notation: 'business_service' })).toContain('BSV-001');
-  });
-
-  it('flags a non-canon zone', () => {
-    expect(codes({ ...valid(), zone: 'sandbox' })).toContain('BSV-001');
-  });
-
-  it('flags a missing zone', () => {
-    const a = valid();
-    delete a.zone;
-    expect(codes(a)).toContain('BSV-001');
-  });
-
-  it('flags a missing type', () => {
-    const a = valid();
-    delete a.type;
-    expect(codes(a)).toContain('BSV-001');
-  });
-
-  it('flags a missing valid_to key', () => {
-    const a = valid();
-    delete a.valid_to;
-    expect(codes(a)).toContain('BSV-001');
-  });
-
-  it('flags missing gate_checks', () => {
-    const a = valid();
-    delete a.gate_checks;
-    expect(codes(a)).toContain('BSV-001');
-  });
-
-  it('rejects a non-object', () => {
-    expect(codes(null)).toEqual(['BSV-001']);
-    expect(codes('string')).toEqual(['BSV-001']);
-  });
-});
-
-describe('validateBusinessService — BSV-002 (type enum)', () => {
-  it('flags a type outside the allowed enum', () => {
-    expect(codes({ ...valid(), type: 'public' })).toContain('BSV-002');
-    expect(codes({ ...valid(), type: 'platform' })).toContain('BSV-002');
-  });
-
-  it('accepts all valid type values', () => {
-    for (const t of ['internal', 'external', 'shared']) {
-      expect(codes({ ...valid(), type: t })).not.toContain('BSV-002');
-    }
-  });
-});
-
-describe('validateBusinessService — BSV-003 (offering_unit grammar)', () => {
-  it('flags an offering_unit that is not an ACTOR-… or ROLE-… id', () => {
-    expect(codes({ ...valid(), offering_unit: 'PRODUCT-PLATFORM-1' })).toContain('BSV-003');
-    expect(codes({ ...valid(), offering_unit: 'not-an-id' })).toContain('BSV-003');
-    expect(codes({ ...valid(), offering_unit: 'BUSINESS_SERVICE-CRM-1' })).toContain('BSV-003');
-  });
-
-  it('accepts a null or absent offering_unit without error', () => {
-    expect(codes({ ...valid(), offering_unit: undefined })).not.toContain('BSV-003');
-    const a = valid();
-    delete a.offering_unit;
-    expect(codes(a)).not.toContain('BSV-003');
-  });
-
-  it('accepts ACTOR-… and ROLE-… ids', () => {
-    expect(codes({ ...valid(), offering_unit: 'ACTOR-OPS-1' })).not.toContain('BSV-003');
-    expect(codes({ ...valid(), offering_unit: 'ROLE-SERVICE-OWNER-1' })).not.toContain('BSV-003');
-  });
-});
-
-describe('validateBusinessService — BSV-004 (capability grammar)', () => {
-  it('flags a capability that is not a CAPABILITY-… id', () => {
-    expect(codes({ ...valid(), capability: 'PRODUCT-MOBILE-1' })).toContain('BSV-004');
-    expect(codes({ ...valid(), capability: 'not-a-capability' })).toContain('BSV-004');
-  });
-
-  it('accepts a null or absent capability without error', () => {
-    expect(codes({ ...valid(), capability: undefined })).not.toContain('BSV-004');
-    const a = valid();
-    delete a.capability;
-    expect(codes(a)).not.toContain('BSV-004');
-  });
-
-  it('accepts a CAPABILITY-… id', () => {
-    expect(codes({ ...valid(), capability: 'CAPABILITY-V2.1' })).not.toContain('BSV-004');
-    expect(codes({ ...valid(), capability: 'CAPABILITY-H3.1' })).not.toContain('BSV-004');
-  });
-});