@plures/praxis 1.0.2 → 1.1.0

package/src/__tests__/cloud.test.ts

@@ -2,25 +2,25 @@
  * Cloud Relay Tests
  */
 
-import { describe, it, expect, beforeEach, vi } from "vitest";
-import { createCloudRelay } from "../cloud/client.js";
-import type { CloudRelayConfig, HealthCheckResponse, UsageMetrics } from "../cloud/types.js";
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { createCloudRelay } from '../cloud/client.js';
+import type { CloudRelayConfig, HealthCheckResponse, UsageMetrics } from '../cloud/types.js';
 
-describe("Cloud Relay Client", () => {
+describe('Cloud Relay Client', () => {
   let config: CloudRelayConfig;
 
   beforeEach(() => {
     config = {
-      endpoint: "https://test.example.com",
-      appId: "test-app",
-      authToken: "test-token",
+      endpoint: 'https://test.example.com',
+      appId: 'test-app',
+      authToken: 'test-token',
     };
 
     // Mock fetch globally
     global.fetch = vi.fn();
   });
 
-  it("should create a cloud relay client", () => {
+  it('should create a cloud relay client', () => {
     const client = createCloudRelay(config);
     expect(client).toBeDefined();
     expect(client.getStatus).toBeDefined();
@@ -31,7 +31,7 @@ describe("Cloud Relay Client", () => {
     expect(client.getHealth).toBeDefined();
   });
 
-  it("should return initial status as disconnected", () => {
+  it('should return initial status as disconnected', () => {
     const client = createCloudRelay(config);
     const status = client.getStatus();
     expect(status.connected).toBe(false);
@@ -39,11 +39,11 @@ describe("Cloud Relay Client", () => {
     expect(status.appId).toBe(config.appId);
   });
 
-  it("should connect to relay successfully", async () => {
+  it('should connect to relay successfully', async () => {
     const mockHealthResponse: HealthCheckResponse = {
-      status: "healthy",
+      status: 'healthy',
       timestamp: Date.now(),
-      version: "0.1.0",
+      version: '0.1.0',
       services: {
         relay: true,
         eventGrid: true,
@@ -65,21 +65,21 @@ describe("Cloud Relay Client", () => {
     expect(status.lastSync).toBeDefined();
   });
 
-  it("should throw error when connecting to unavailable endpoint", async () => {
+  it('should throw error when connecting to unavailable endpoint', async () => {
     (global.fetch as any).mockResolvedValueOnce({
       ok: false,
-      statusText: "Service Unavailable",
+      statusText: 'Service Unavailable',
     });
 
     const client = createCloudRelay(config);
-    await expect(client.connect()).rejects.toThrow("Health check failed");
+    await expect(client.connect()).rejects.toThrow('Health check failed');
   });
 
-  it("should sync facts and events", async () => {
+  it('should sync facts and events', async () => {
     const mockHealthResponse: HealthCheckResponse = {
-      status: "healthy",
+      status: 'healthy',
       timestamp: Date.now(),
-      version: "0.1.0",
+      version: '0.1.0',
       services: {
         relay: true,
         eventGrid: true,
@@ -90,7 +90,7 @@ describe("Cloud Relay Client", () => {
 
     const mockSyncResponse = {
       success: true,
-      clock: { "test-app": 1 },
+      clock: { 'test-app': 1 },
       timestamp: Date.now(),
     };
 
@@ -108,10 +108,10 @@ describe("Cloud Relay Client", () => {
     await client.connect();
 
     await client.sync({
-      type: "delta",
+      type: 'delta',
       appId: config.appId,
       clock: {},
-      facts: [{ tag: "TestFact", payload: { value: 42 } }],
+      facts: [{ tag: 'TestFact', payload: { value: 42 } }],
       events: [],
       timestamp: Date.now(),
     });
@@ -119,11 +119,11 @@ describe("Cloud Relay Client", () => {
     expect(global.fetch).toHaveBeenCalledTimes(2);
   });
 
-  it("should get usage metrics", async () => {
+  it('should get usage metrics', async () => {
     const mockHealthResponse: HealthCheckResponse = {
-      status: "healthy",
+      status: 'healthy',
       timestamp: Date.now(),
-      version: "0.1.0",
+      version: '0.1.0',
       services: {
         relay: true,
         eventGrid: true,
@@ -161,11 +161,11 @@ describe("Cloud Relay Client", () => {
     expect(usage.eventCount).toBe(50);
   });
 
-  it("should get health status", async () => {
+  it('should get health status', async () => {
     const mockHealthResponse: HealthCheckResponse = {
-      status: "healthy",
+      status: 'healthy',
       timestamp: Date.now(),
-      version: "0.1.0",
+      version: '0.1.0',
       services: {
         relay: true,
         eventGrid: true,
@@ -188,15 +188,15 @@ describe("Cloud Relay Client", () => {
     await client.connect();
 
     const health = await client.getHealth();
-    expect(health.status).toBe("healthy");
+    expect(health.status).toBe('healthy');
     expect(health.services.relay).toBe(true);
   });
 
-  it("should disconnect and clear auto-sync timer", async () => {
+  it('should disconnect and clear auto-sync timer', async () => {
     const mockHealthResponse: HealthCheckResponse = {
-      status: "healthy",
+      status: 'healthy',
       timestamp: Date.now(),
-      version: "0.1.0",
+      version: '0.1.0',
       services: {
         relay: true,
         eventGrid: true,
@@ -225,23 +225,23 @@ describe("Cloud Relay Client", () => {
     expect(statusAfter.connected).toBe(false);
   });
 
-  it("should throw error when syncing while disconnected", async () => {
+  it('should throw error when syncing while disconnected', async () => {
     const client = createCloudRelay(config);
 
     await expect(
       client.sync({
-        type: "delta",
+        type: 'delta',
         appId: config.appId,
         clock: {},
         facts: [],
         events: [],
         timestamp: Date.now(),
       })
-    ).rejects.toThrow("Not connected");
+    ).rejects.toThrow('Not connected');
   });
 
-  it("should throw error when getting usage while disconnected", async () => {
+  it('should throw error when getting usage while disconnected', async () => {
     const client = createCloudRelay(config);
-    await expect(client.getUsage()).rejects.toThrow("Not connected");
+    await expect(client.getUsage()).rejects.toThrow('Not connected');
   });
 });

package/src/__tests__/code-canvas-integration.test.ts

@@ -2,7 +2,7 @@
  * CodeCanvas Integration Tests
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from 'vitest';
 import {
   schemaToCanvas,
   canvasToSchema,
@@ -10,268 +10,259 @@ import {
   canvasToMermaid,
   createCanvasEditor,
   validateWithGuardian,
-} from "../integrations/code-canvas.js";
-import type { PraxisSchema } from "../core/schema/types.js";
-
-describe("CodeCanvas Integration", () => {
-  const testSchema: PraxisSchema = {
-    version: "1.0.0",
-    name: "TestSchema",
-    description: "A test schema",
+} from '../integrations/code-canvas.js';
+import type { PSFSchema } from '../../core/schema-engine/psf.js';
+
+describe('CodeCanvas Integration', () => {
+  const testSchema: PSFSchema = {
+    $version: '1.0.0',
+    id: 'test-schema',
+    name: 'TestSchema',
+    description: 'A test schema',
     models: [
       {
-        name: "User",
-        description: "User model",
+        name: 'User',
+        description: 'User model',
         fields: [
-          { name: "id", type: "string" },
-          { name: "name", type: "string" },
+          { name: 'id', type: 'string' },
+          { name: 'name', type: 'string' },
         ],
       },
     ],
     components: [
       {
-        name: "UserForm",
-        type: "form",
-        description: "User form component",
-        model: "User",
+        name: 'UserForm',
+        type: 'form',
+        description: 'User form component',
+        model: 'User',
       },
     ],
-    logic: [
+    events: [
+      { tag: 'UserCreated', payload: { userId: 'string' }, description: 'User was created' },
+    ],
+    facts: [{ tag: 'UserExists', payload: { userId: 'string' }, description: 'User exists' }],
+    rules: [{ id: 'create-user', description: 'Create user rule', then: 'createUser()' }],
+    constraints: [
       {
-        id: "user-logic",
-        description: "User logic module",
-        events: [
-          { tag: "UserCreated", payload: { userId: "string" }, description: "User was created" },
-        ],
-        facts: [
-          { tag: "UserExists", payload: { userId: "string" }, description: "User exists" },
-        ],
-        rules: [
-          { id: "create-user", description: "Create user rule", then: "createUser()" },
-        ],
-        constraints: [
-          { id: "user-name-required", description: "Name is required", check: "name !== null", message: "Name is required" },
-        ],
+        id: 'user-name-required',
+        description: 'Name is required',
+        check: 'name !== null',
+        message: 'Name is required',
       },
     ],
+    flows: [],
   };
 
-  describe("schemaToCanvas", () => {
-    it("should convert a schema to canvas document", () => {
+  describe('schemaToCanvas', () => {
+    it('should convert a schema to canvas document', () => {
       const canvas = schemaToCanvas(testSchema);
-      
+
       expect(canvas).toBeDefined();
-      expect(canvas.name).toBe("TestSchema");
-      expect(canvas.version).toBe("1.0.0");
+      expect(canvas.name).toBe('TestSchema');
+      expect(canvas.version).toBe('1.0.0');
       expect(canvas.nodes.length).toBeGreaterThan(0);
     });
-    
-    it("should create nodes for models", () => {
+
+    it('should create nodes for models', () => {
       const canvas = schemaToCanvas(testSchema);
-      const modelNodes = canvas.nodes.filter(n => n.type === "model");
-      
+      const modelNodes = canvas.nodes.filter((n) => n.type === 'model');
+
       expect(modelNodes.length).toBe(1);
-      expect(modelNodes[0].label).toBe("User");
+      expect(modelNodes[0].label).toBe('User');
     });
-    
-    it("should create nodes for components", () => {
+
+    it('should create nodes for components', () => {
       const canvas = schemaToCanvas(testSchema);
-      const componentNodes = canvas.nodes.filter(n => n.type === "component");
-      
+      const componentNodes = canvas.nodes.filter((n) => n.type === 'component');
+
       expect(componentNodes.length).toBe(1);
-      expect(componentNodes[0].label).toBe("UserForm");
+      expect(componentNodes[0].label).toBe('UserForm');
     });
-    
-    it("should create nodes for events", () => {
+
+    it('should create nodes for events', () => {
       const canvas = schemaToCanvas(testSchema);
-      const eventNodes = canvas.nodes.filter(n => n.type === "event");
-      
+      const eventNodes = canvas.nodes.filter((n) => n.type === 'event');
+
       expect(eventNodes.length).toBe(1);
-      expect(eventNodes[0].label).toBe("UserCreated");
+      expect(eventNodes[0].label).toBe('UserCreated');
     });
-    
-    it("should create edges for component-model relationships", () => {
+
+    it('should create edges for component-model relationships', () => {
       const canvas = schemaToCanvas(testSchema);
-      
+
       expect(canvas.edges.length).toBeGreaterThan(0);
-      expect(canvas.edges[0].type).toBe("reference");
+      expect(canvas.edges[0].type).toBe('reference');
     });
   });
 
-  describe("canvasToSchema", () => {
-    it("should convert canvas back to schema", () => {
+  describe('canvasToSchema', () => {
+    it('should convert canvas back to schema', () => {
       const canvas = schemaToCanvas(testSchema);
       const schema = canvasToSchema(canvas);
-      
+
       expect(schema).toBeDefined();
-      expect(schema.name).toBe("TestSchema");
-      expect(schema.version).toBe("1.0.0");
+      expect(schema.name).toBe('TestSchema');
+      expect(schema.$version).toBe('1.0.0');
     });
-    
-    it("should preserve models", () => {
+
+    it('should preserve models', () => {
       const canvas = schemaToCanvas(testSchema);
       const schema = canvasToSchema(canvas);
-      
+
       expect(schema.models?.length).toBe(1);
-      expect(schema.models?.[0].name).toBe("User");
+      expect(schema.models?.[0].name).toBe('User');
     });
-    
-    it("should preserve components", () => {
+
+    it('should preserve components', () => {
       const canvas = schemaToCanvas(testSchema);
       const schema = canvasToSchema(canvas);
-      
+
       expect(schema.components?.length).toBe(1);
-      expect(schema.components?.[0].name).toBe("UserForm");
+      expect(schema.components?.[0].name).toBe('UserForm');
     });
   });
 
-  describe("canvasToYaml", () => {
-    it("should export canvas to YAML format", () => {
+  describe('canvasToYaml', () => {
+    it('should export canvas to YAML format', () => {
       const canvas = schemaToCanvas(testSchema);
       const yaml = canvasToYaml(canvas);
-      
-      expect(yaml).toContain("# TestSchema");
-      expect(yaml).toContain("nodes:");
-      expect(yaml).toContain("edges:");
+
+      expect(yaml).toContain('# TestSchema');
+      expect(yaml).toContain('nodes:');
+      expect(yaml).toContain('edges:');
     });
   });
 
-  describe("canvasToMermaid", () => {
-    it("should export canvas to Mermaid format", () => {
+  describe('canvasToMermaid', () => {
+    it('should export canvas to Mermaid format', () => {
       const canvas = schemaToCanvas(testSchema);
       const mermaid = canvasToMermaid(canvas);
-      
-      expect(mermaid).toContain("graph TD");
-      expect(mermaid).toContain("User");
+
+      expect(mermaid).toContain('graph TD');
+      expect(mermaid).toContain('User');
     });
   });
 
-  describe("createCanvasEditor", () => {
-    it("should create an editor from schema", () => {
+  describe('createCanvasEditor', () => {
+    it('should create an editor from schema', () => {
       const editor = createCanvasEditor({ schema: testSchema });
-      
+
       expect(editor).toBeDefined();
       expect(editor.document).toBeDefined();
       expect(editor.document.nodes.length).toBeGreaterThan(0);
     });
-    
-    it("should add nodes", () => {
+
+    it('should add nodes', () => {
       const editor = createCanvasEditor({ schema: testSchema });
       const initialCount = editor.document.nodes.length;
-      
+
       editor.addNode({
-        type: "model",
-        label: "NewModel",
+        type: 'model',
+        label: 'NewModel',
         x: 0,
         y: 0,
         width: 100,
         height: 50,
       });
-      
+
       expect(editor.document.nodes.length).toBe(initialCount + 1);
     });
-    
-    it("should remove nodes", () => {
+
+    it('should remove nodes', () => {
       const editor = createCanvasEditor({ schema: testSchema });
       const node = editor.document.nodes[0];
       const initialCount = editor.document.nodes.length;
-      
+
       editor.removeNode(node.id);
-      
+
       expect(editor.document.nodes.length).toBe(initialCount - 1);
     });
-    
-    it("should add edges", () => {
+
+    it('should add edges', () => {
       const editor = createCanvasEditor({ schema: testSchema });
       const initialCount = editor.document.edges.length;
-      
+
       const nodes = editor.document.nodes;
       if (nodes.length >= 2) {
         editor.addEdge({
           source: nodes[0].id,
           target: nodes[1].id,
-          type: "dependency",
+          type: 'dependency',
         });
-        
+
         expect(editor.document.edges.length).toBe(initialCount + 1);
       }
     });
-    
-    it("should export to schema", () => {
+
+    it('should export to schema', () => {
       const editor = createCanvasEditor({ schema: testSchema });
       const schema = editor.toSchema();
-      
+
       expect(schema).toBeDefined();
-      expect(schema.name).toBe("TestSchema");
+      expect(schema.name).toBe('TestSchema');
     });
-    
-    it("should export to YAML", () => {
+
+    it('should export to YAML', () => {
       const editor = createCanvasEditor({ schema: testSchema });
       const yaml = editor.toYaml();
-      
-      expect(yaml).toContain("# TestSchema");
+
+      expect(yaml).toContain('# TestSchema');
     });
-    
-    it("should export to Mermaid", () => {
+
+    it('should export to Mermaid', () => {
       const editor = createCanvasEditor({ schema: testSchema });
       const mermaid = editor.toMermaid();
-      
-      expect(mermaid).toContain("graph TD");
+
+      expect(mermaid).toContain('graph TD');
     });
   });
 
-  describe("validateWithGuardian", () => {
-    it("should validate files against activity", () => {
+  describe('validateWithGuardian', () => {
+    it('should validate files against activity', () => {
       const result = validateWithGuardian(
-        ["src/models/user.ts"],
+        ['src/models/user.ts'],
         {
-          activity: "implementing",
-          actor: "developer",
+          activity: 'implementing',
+          actor: 'developer',
           startedAt: Date.now(),
-          allowedPaths: ["src/**/*"],
+          allowedPaths: ['src/**/*'],
         },
-        [
-          { id: "implementing", name: "Implementing", transitions: ["testing"] },
-        ]
+        [{ id: 'implementing', name: 'Implementing', transitions: ['testing'] }]
       );
-      
+
       expect(result.valid).toBe(true);
       expect(result.errors.length).toBe(0);
     });
-    
-    it("should fail for invalid activity", () => {
+
+    it('should fail for invalid activity', () => {
       const result = validateWithGuardian(
-        ["src/models/user.ts"],
+        ['src/models/user.ts'],
         {
-          activity: "invalid" as any,
-          actor: "developer",
+          activity: 'invalid' as any,
+          actor: 'developer',
           startedAt: Date.now(),
         },
-        [
-          { id: "implementing", name: "Implementing", transitions: [] },
-        ]
+        [{ id: 'implementing', name: 'Implementing', transitions: [] }]
       );
-      
+
       expect(result.valid).toBe(false);
-      expect(result.errors.some(e => e.code === "INVALID_ACTIVITY")).toBe(true);
+      expect(result.errors.some((e) => e.code === 'INVALID_ACTIVITY')).toBe(true);
     });
-    
-    it("should fail for disallowed paths", () => {
+
+    it('should fail for disallowed paths', () => {
       const result = validateWithGuardian(
-        ["config/secrets.json"],
+        ['config/secrets.json'],
         {
-          activity: "implementing",
-          actor: "developer",
+          activity: 'implementing',
+          actor: 'developer',
           startedAt: Date.now(),
-          allowedPaths: ["src/**/*"],
+          allowedPaths: ['src/**/*'],
         },
-        [
-          { id: "implementing", name: "Implementing", transitions: [] },
-        ]
+        [{ id: 'implementing', name: 'Implementing', transitions: [] }]
       );
-      
+
       expect(result.valid).toBe(false);
-      expect(result.errors.some(e => e.code === "PATH_NOT_ALLOWED")).toBe(true);
+      expect(result.errors.some((e) => e.code === 'PATH_NOT_ALLOWED')).toBe(true);
     });
   });
 });

package/src/__tests__/docs-generator.test.ts

@@ -92,12 +92,8 @@ describe('Documentation Generator', () => {
         name: 'UserForm',
         type: 'form',
         description: 'Form for creating users',
-        props: [
-          { name: 'title', type: 'string', required: true, description: 'Form title' },
-        ],
-        events: [
-          { name: 'submit', payload: 'User', description: 'Form submitted' },
-        ],
+        props: [{ name: 'title', type: 'string', required: true, description: 'Form title' }],
+        events: [{ name: 'submit', payload: 'User', description: 'Form submitted' }],
       },
     ];
 
@@ -118,9 +114,7 @@ describe('Documentation Generator', () => {
         id: 'model_1',
         name: 'User',
         fields: [{ name: 'id', type: 'string' }],
-        relationships: [
-          { name: 'posts', type: 'one-to-many', target: 'Post' },
-        ],
+        relationships: [{ name: 'posts', type: 'one-to-many', target: 'Post' }],
       },
       {
         id: 'model_2',