@plures/praxis 0.2.1 → 1.0.0

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

@@ -0,0 +1,277 @@
+/**
+ * CodeCanvas Integration Tests
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  schemaToCanvas,
+  canvasToSchema,
+  canvasToYaml,
+  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",
+    models: [
+      {
+        name: "User",
+        description: "User model",
+        fields: [
+          { name: "id", type: "string" },
+          { name: "name", type: "string" },
+        ],
+      },
+    ],
+    components: [
+      {
+        name: "UserForm",
+        type: "form",
+        description: "User form component",
+        model: "User",
+      },
+    ],
+    logic: [
+      {
+        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" },
+        ],
+      },
+    ],
+  };
+
+  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.nodes.length).toBeGreaterThan(0);
+    });
+    
+    it("should create nodes for models", () => {
+      const canvas = schemaToCanvas(testSchema);
+      const modelNodes = canvas.nodes.filter(n => n.type === "model");
+      
+      expect(modelNodes.length).toBe(1);
+      expect(modelNodes[0].label).toBe("User");
+    });
+    
+    it("should create nodes for components", () => {
+      const canvas = schemaToCanvas(testSchema);
+      const componentNodes = canvas.nodes.filter(n => n.type === "component");
+      
+      expect(componentNodes.length).toBe(1);
+      expect(componentNodes[0].label).toBe("UserForm");
+    });
+    
+    it("should create nodes for events", () => {
+      const canvas = schemaToCanvas(testSchema);
+      const eventNodes = canvas.nodes.filter(n => n.type === "event");
+      
+      expect(eventNodes.length).toBe(1);
+      expect(eventNodes[0].label).toBe("UserCreated");
+    });
+    
+    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");
+    });
+  });
+
+  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");
+    });
+    
+    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");
+    });
+    
+    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");
+    });
+  });
+
+  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:");
+    });
+  });
+
+  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");
+    });
+  });
+
+  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", () => {
+      const editor = createCanvasEditor({ schema: testSchema });
+      const initialCount = editor.document.nodes.length;
+      
+      editor.addNode({
+        type: "model",
+        label: "NewModel",
+        x: 0,
+        y: 0,
+        width: 100,
+        height: 50,
+      });
+      
+      expect(editor.document.nodes.length).toBe(initialCount + 1);
+    });
+    
+    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", () => {
+      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",
+        });
+        
+        expect(editor.document.edges.length).toBe(initialCount + 1);
+      }
+    });
+    
+    it("should export to schema", () => {
+      const editor = createCanvasEditor({ schema: testSchema });
+      const schema = editor.toSchema();
+      
+      expect(schema).toBeDefined();
+      expect(schema.name).toBe("TestSchema");
+    });
+    
+    it("should export to YAML", () => {
+      const editor = createCanvasEditor({ schema: testSchema });
+      const yaml = editor.toYaml();
+      
+      expect(yaml).toContain("# TestSchema");
+    });
+    
+    it("should export to Mermaid", () => {
+      const editor = createCanvasEditor({ schema: testSchema });
+      const mermaid = editor.toMermaid();
+      
+      expect(mermaid).toContain("graph TD");
+    });
+  });
+
+  describe("validateWithGuardian", () => {
+    it("should validate files against activity", () => {
+      const result = validateWithGuardian(
+        ["src/models/user.ts"],
+        {
+          activity: "implementing",
+          actor: "developer",
+          startedAt: Date.now(),
+          allowedPaths: ["src/**/*"],
+        },
+        [
+          { id: "implementing", name: "Implementing", transitions: ["testing"] },
+        ]
+      );
+      
+      expect(result.valid).toBe(true);
+      expect(result.errors.length).toBe(0);
+    });
+    
+    it("should fail for invalid activity", () => {
+      const result = validateWithGuardian(
+        ["src/models/user.ts"],
+        {
+          activity: "invalid" as any,
+          actor: "developer",
+          startedAt: Date.now(),
+        },
+        [
+          { id: "implementing", name: "Implementing", transitions: [] },
+        ]
+      );
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === "INVALID_ACTIVITY")).toBe(true);
+    });
+    
+    it("should fail for disallowed paths", () => {
+      const result = validateWithGuardian(
+        ["config/secrets.json"],
+        {
+          activity: "implementing",
+          actor: "developer",
+          startedAt: Date.now(),
+          allowedPaths: ["src/**/*"],
+        },
+        [
+          { id: "implementing", name: "Implementing", transitions: [] },
+        ]
+      );
+      
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.code === "PATH_NOT_ALLOWED")).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,181 @@
+/**
+ * Documentation Generator Tests
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createEmptyPSFSchema } from '../../core/schema-engine/psf.js';
+import { generateDocs, DocsGenerator } from '../../core/codegen/docs-generator.js';
+
+describe('Documentation Generator', () => {
+  it('should generate overview document', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+    schema.description = 'A test application';
+
+    const result = generateDocs(schema);
+
+    expect(result.success).toBe(true);
+    const overview = result.files.find((f) => f.type === 'overview');
+    expect(overview).toBeDefined();
+    expect(overview?.content).toContain('# Test App');
+    expect(overview?.content).toContain('A test application');
+  });
+
+  it('should generate API reference with facts and events', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+    schema.facts = [
+      {
+        id: 'fact_1',
+        tag: 'UserCreated',
+        description: 'User was created',
+        payload: {
+          type: 'object',
+          properties: {
+            userId: { type: 'string', description: 'User ID' },
+          },
+        },
+      },
+    ];
+    schema.events = [
+      {
+        id: 'event_1',
+        tag: 'CreateUser',
+        description: 'Create a user',
+        payload: {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+          },
+        },
+      },
+    ];
+
+    const result = generateDocs(schema, { includeApiReference: true, includeExamples: true });
+
+    expect(result.success).toBe(true);
+    const api = result.files.find((f) => f.type === 'api');
+    expect(api).toBeDefined();
+    expect(api?.content).toContain('UserCreated');
+    expect(api?.content).toContain('CreateUser');
+    expect(api?.content).toContain('User was created');
+  });
+
+  it('should generate models documentation', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+    schema.models = [
+      {
+        id: 'model_1',
+        name: 'User',
+        description: 'A user entity',
+        fields: [
+          { name: 'id', type: 'uuid', description: 'User ID' },
+          { name: 'name', type: 'string', description: 'User name' },
+          { name: 'email', type: 'string', optional: true },
+        ],
+      },
+    ];
+
+    const result = generateDocs(schema);
+
+    expect(result.success).toBe(true);
+    const models = result.files.find((f) => f.type === 'model');
+    expect(models).toBeDefined();
+    expect(models?.content).toContain('# Data Models');
+    expect(models?.content).toContain('## User');
+    expect(models?.content).toContain('| `id` | `uuid` | No | User ID |');
+  });
+
+  it('should generate components documentation', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+    schema.components = [
+      {
+        id: 'comp_1',
+        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' },
+        ],
+      },
+    ];
+
+    const result = generateDocs(schema);
+
+    expect(result.success).toBe(true);
+    const components = result.files.find((f) => f.type === 'component');
+    expect(components).toBeDefined();
+    expect(components?.content).toContain('# UI Components');
+    expect(components?.content).toContain('## UserForm');
+    expect(components?.content).toContain('Form for creating users');
+  });
+
+  it('should generate Mermaid diagrams', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+    schema.models = [
+      {
+        id: 'model_1',
+        name: 'User',
+        fields: [{ name: 'id', type: 'string' }],
+        relationships: [
+          { name: 'posts', type: 'one-to-many', target: 'Post' },
+        ],
+      },
+      {
+        id: 'model_2',
+        name: 'Post',
+        fields: [{ name: 'id', type: 'string' }],
+      },
+    ];
+    schema.rules = [
+      {
+        id: 'user.create',
+        name: 'Create User',
+        description: 'Create a new user',
+        triggers: ['CreateUser'],
+        then: { inline: 'return []' },
+      },
+    ];
+
+    const result = generateDocs(schema, { includeDiagrams: true });
+
+    expect(result.success).toBe(true);
+    const diagrams = result.files.find((f) => f.type === 'diagram');
+    expect(diagrams).toBeDefined();
+    expect(diagrams?.content).toContain('```mermaid');
+    expect(diagrams?.content).toContain('erDiagram');
+    expect(diagrams?.content).toContain('flowchart LR');
+  });
+
+  it('should generate index document', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+    schema.facts = [{ id: 'f1', tag: 'Test', payload: { type: 'object', properties: {} } }];
+
+    const result = generateDocs(schema);
+
+    expect(result.success).toBe(true);
+    const index = result.files.find((f) => f.type === 'index');
+    expect(index).toBeDefined();
+    expect(index?.content).toContain('# Test App Documentation');
+    expect(index?.content).toContain('overview.md');
+  });
+
+  it('should respect generator options', () => {
+    const schema = createEmptyPSFSchema('test', 'Test App');
+
+    const generator = new DocsGenerator({
+      outputDir: './custom-docs',
+      includeDiagrams: false,
+      includeApiReference: false,
+      includeExamples: false,
+    });
+
+    const result = generator.generate(schema);
+
+    expect(result.success).toBe(true);
+    expect(result.files.some((f) => f.type === 'diagram')).toBe(false);
+    expect(result.files.some((f) => f.type === 'api')).toBe(false);
+    expect(result.files[0].path).toContain('./custom-docs');
+  });
+});

package/src/__tests__/generators.test.ts

@@ -262,9 +262,10 @@ describe('Code Generators', () => {
       const files = generator.generateConfig(normalized);
       const configFile = files[0];
       
-      // Should have no auto-generated indexes
-      expect(configFile.content).not.toContain('indexes:');
+      // Should indicate auto-indexing is disabled in comment
       expect(configFile.content).toContain('Auto-indexing disabled');
+      // Store config should not have indexes array (since none are auto-generated)
+      expect(configFile.content).not.toMatch(/users:\s*\{\s*keyPath:\s*'id',\s*indexes:/);
     });
   });
 });