@plures/praxis 0.2.0

package/src/__tests__/generators.test.ts

@@ -0,0 +1,270 @@
+import { describe, it, expect } from 'vitest';
+import { createLogicGenerator } from '../core/logic/generator.js';
+import { createComponentGenerator } from '../core/component/generator.js';
+import { createPluresDBGenerator } from '../core/pluresdb/generator.js';
+import { normalizeSchema } from '../core/schema/normalize.js';
+import type { PraxisSchema } from '../core/schema/types.js';
+
+describe('Code Generators', () => {
+  const testSchema: PraxisSchema = {
+    version: '1.0.0',
+    name: 'TestApp',
+    models: [
+      {
+        name: 'User',
+        fields: [
+          { name: 'id', type: 'string' },
+          { name: 'name', type: 'string' },
+          { name: 'email', type: 'string' },
+        ],
+      },
+    ],
+    components: [
+      {
+        name: 'UserForm',
+        type: 'form',
+        model: 'User',
+      },
+    ],
+    logic: [
+      {
+        id: 'user-logic',
+        description: 'User logic',
+        events: [
+          {
+            tag: 'CREATE_USER',
+            payload: { name: 'string', email: 'string' },
+          },
+        ],
+        facts: [
+          {
+            tag: 'UserCreated',
+            payload: { userId: 'string' },
+          },
+        ],
+      },
+    ],
+  };
+
+  describe('LogicGenerator', () => {
+    it('generates logic files', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createLogicGenerator('/tmp/test');
+      
+      const files = generator.generateLogic(normalized);
+      
+      expect(files).toHaveLength(5);
+      expect(files.map(f => f.type)).toContain('facts');
+      expect(files.map(f => f.type)).toContain('events');
+      expect(files.map(f => f.type)).toContain('rules');
+      expect(files.map(f => f.type)).toContain('engine');
+      expect(files.map(f => f.type)).toContain('index');
+    });
+
+    it('generates facts with correct types', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createLogicGenerator('/tmp/test');
+      
+      const files = generator.generateLogic(normalized);
+      const factsFile = files.find(f => f.type === 'facts');
+      
+      expect(factsFile).toBeDefined();
+      expect(factsFile?.content).toContain('UserCreated');
+      expect(factsFile?.content).toContain('defineFact');
+      expect(factsFile?.content).toContain('userId: string');
+    });
+
+    it('generates events with correct types', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createLogicGenerator('/tmp/test');
+      
+      const files = generator.generateLogic(normalized);
+      const eventsFile = files.find(f => f.type === 'events');
+      
+      expect(eventsFile).toBeDefined();
+      expect(eventsFile?.content).toContain('CREATE_USER');
+      expect(eventsFile?.content).toContain('defineEvent');
+      expect(eventsFile?.content).toContain('name: string');
+      expect(eventsFile?.content).toContain('email: string');
+    });
+
+    it('generates engine with model types', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createLogicGenerator('/tmp/test');
+      
+      const files = generator.generateLogic(normalized);
+      const engineFile = files.find(f => f.type === 'engine');
+      
+      expect(engineFile).toBeDefined();
+      expect(engineFile?.content).toContain('interface User');
+      expect(engineFile?.content).toContain('id: string');
+      expect(engineFile?.content).toContain('name: string');
+      expect(engineFile?.content).toContain('email: string');
+    });
+  });
+
+  describe('ComponentGenerator', () => {
+    it('generates component files', () => {
+      const component = testSchema.components![0];
+      const model = testSchema.models![0];
+      const generator = createComponentGenerator('/tmp/test', {
+        typescript: true,
+        includeDocs: true,
+      });
+      
+      const result = generator.generateComponent(component, model);
+      
+      expect(result.success).toBe(true);
+      expect(result.files.length).toBeGreaterThan(0);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('generates Svelte component with form fields', () => {
+      const component = testSchema.components![0];
+      const model = testSchema.models![0];
+      const generator = createComponentGenerator('/tmp/test');
+      
+      const result = generator.generateComponent(component, model);
+      const componentFile = result.files.find(f => f.type === 'component');
+      
+      expect(componentFile).toBeDefined();
+      expect(componentFile?.content).toContain('<form');
+      expect(componentFile?.content).toContain('input');
+      expect(componentFile?.content).toContain('id');
+      expect(componentFile?.content).toContain('name');
+      expect(componentFile?.content).toContain('email');
+    });
+
+    it('generates TypeScript types when enabled', () => {
+      const component = testSchema.components![0];
+      const model = testSchema.models![0];
+      const generator = createComponentGenerator('/tmp/test', {
+        typescript: true,
+      });
+      
+      const result = generator.generateComponent(component, model);
+      const typesFile = result.files.find(f => f.type === 'types');
+      
+      expect(typesFile).toBeDefined();
+      expect(typesFile?.content).toContain('interface User');
+    });
+
+    it('generates documentation when enabled', () => {
+      const component = testSchema.components![0];
+      const model = testSchema.models![0];
+      const generator = createComponentGenerator('/tmp/test', {
+        includeDocs: true,
+      });
+      
+      const result = generator.generateComponent(component, model);
+      const docsFile = result.files.find(f => f.type === 'docs');
+      
+      expect(docsFile).toBeDefined();
+      expect(docsFile?.content).toContain('# UserForm');
+    });
+  });
+
+  describe('PluresDBGenerator', () => {
+    it('generates PluresDB config', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createPluresDBGenerator('/tmp/test');
+      
+      const files = generator.generateConfig(normalized);
+      
+      expect(files).toHaveLength(1);
+      expect(files[0].type).toBe('config');
+    });
+
+    it('generates stores for models', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createPluresDBGenerator('/tmp/test');
+      
+      const files = generator.generateConfig(normalized);
+      const configFile = files[0];
+      
+      expect(configFile.content).toContain('users:');
+      expect(configFile.content).toContain("keyPath: 'id'");
+      expect(configFile.content).toContain('indexes:');
+    });
+
+    it('includes database name in config', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createPluresDBGenerator('/tmp/test', {
+        dbName: 'custom-db',
+      });
+      
+      const files = generator.generateConfig(normalized);
+      const configFile = files[0];
+      
+      expect(configFile.content).toContain("name: 'custom-db'");
+    });
+
+    it('includes sync config when enabled', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createPluresDBGenerator('/tmp/test', {
+        enableSync: true,
+        syncEndpoint: 'ws://example.com/sync',
+      });
+      
+      const files = generator.generateConfig(normalized);
+      const configFile = files[0];
+      
+      expect(configFile.content).toContain('sync:');
+      expect(configFile.content).toContain('enabled: true');
+      expect(configFile.content).toContain('ws://example.com/sync');
+    });
+
+    it('respects autoIndex "all" strategy', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createPluresDBGenerator('/tmp/test', {
+        autoIndex: 'all',
+      });
+      
+      const files = generator.generateConfig(normalized);
+      const configFile = files[0];
+      
+      // Should include all string/number/date fields
+      expect(configFile.content).toContain("indexes: ['name', 'email']");
+      expect(configFile.content).toContain('auto-indexed by default');
+    });
+
+    it('respects autoIndex "explicit" strategy', () => {
+      const schemaWithIndexes = {
+        ...testSchema,
+        models: [
+          {
+            ...testSchema.models![0],
+            indexes: [
+              { name: 'email_idx', fields: ['email'] },
+            ],
+          },
+        ],
+      };
+      const normalized = normalizeSchema(schemaWithIndexes);
+      const generator = createPluresDBGenerator('/tmp/test', {
+        autoIndex: 'explicit',
+      });
+      
+      const files = generator.generateConfig(normalized);
+      const configFile = files[0];
+      
+      // Should only include explicitly defined indexes
+      expect(configFile.content).toContain("indexes: ['email']");
+      expect(configFile.content).toContain('explicitly defined in schema');
+    });
+
+    it('respects autoIndex "none" strategy', () => {
+      const normalized = normalizeSchema(testSchema);
+      const generator = createPluresDBGenerator('/tmp/test', {
+        autoIndex: 'none',
+      });
+      
+      const files = generator.generateConfig(normalized);
+      const configFile = files[0];
+      
+      // Should have no auto-generated indexes
+      expect(configFile.content).not.toContain('indexes:');
+      expect(configFile.content).toContain('Auto-indexing disabled');
+    });
+  });
+});

package/src/__tests__/introspection.test.ts

@@ -0,0 +1,321 @@
+/**
+ * Introspection tests
+ */
+
+import { describe, it, expect } from "vitest";
+import { PraxisRegistry } from "../core/rules.js";
+import { defineRule, defineConstraint, defineModule } from "../dsl/index.js";
+import { RegistryIntrospector, createIntrospector } from "../core/introspection.js";
+import { PRAXIS_PROTOCOL_VERSION } from "../core/protocol.js";
+
+describe("Registry Introspection", () => {
+  describe("RegistryIntrospector", () => {
+    it("should get basic statistics", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({ id: "rule1", description: "Rule 1", impl: () => [] })
+      );
+      registry.registerRule(
+        defineRule({ id: "rule2", description: "Rule 2", impl: () => [] })
+      );
+      registry.registerConstraint(
+        defineConstraint({ id: "c1", description: "Constraint 1", impl: () => true })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const stats = introspector.getStats();
+
+      expect(stats.ruleCount).toBe(2);
+      expect(stats.constraintCount).toBe(1);
+      expect(stats.rulesById).toEqual(["rule1", "rule2"]);
+      expect(stats.constraintsById).toEqual(["c1"]);
+    });
+
+    it("should generate schema", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({
+          id: "rule1",
+          description: "Test rule",
+          impl: () => [],
+          meta: { category: "test" },
+        })
+      );
+      registry.registerConstraint(
+        defineConstraint({
+          id: "c1",
+          description: "Test constraint",
+          impl: () => true,
+          meta: { level: "error" },
+        })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const schema = introspector.generateSchema(PRAXIS_PROTOCOL_VERSION);
+
+      expect(schema.protocolVersion).toBe(PRAXIS_PROTOCOL_VERSION);
+      expect(schema.rules).toHaveLength(1);
+      expect(schema.constraints).toHaveLength(1);
+      expect(schema.rules[0]?.id).toBe("rule1");
+      expect(schema.rules[0]?.description).toBe("Test rule");
+      expect(schema.rules[0]?.meta).toEqual({ category: "test" });
+      expect(schema.constraints[0]?.id).toBe("c1");
+      expect(schema.constraints[0]?.meta).toEqual({ level: "error" });
+    });
+
+    it("should generate graph", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({ id: "rule1", description: "Rule 1", impl: () => [] })
+      );
+      registry.registerRule(
+        defineRule({ id: "rule2", description: "Rule 2", impl: () => [] })
+      );
+      registry.registerConstraint(
+        defineConstraint({ id: "c1", description: "Constraint 1", impl: () => true })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const graph = introspector.generateGraph();
+
+      expect(graph.nodes).toHaveLength(3);
+      expect(graph.nodes.filter((n) => n.type === "rule")).toHaveLength(2);
+      expect(graph.nodes.filter((n) => n.type === "constraint")).toHaveLength(1);
+      expect(graph.meta.nodeCount).toBe(3);
+      expect(graph.meta.ruleCount).toBe(2);
+      expect(graph.meta.constraintCount).toBe(1);
+    });
+
+    it("should generate graph with dependencies", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({
+          id: "rule1",
+          description: "Rule 1",
+          impl: () => [],
+          meta: {},
+        })
+      );
+      registry.registerRule(
+        defineRule({
+          id: "rule2",
+          description: "Rule 2 depends on Rule 1",
+          impl: () => [],
+          meta: { dependsOn: "rule1" },
+        })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const graph = introspector.generateGraph();
+
+      expect(graph.edges).toHaveLength(1);
+      expect(graph.edges[0]).toEqual({
+        from: "rule1",
+        to: "rule2",
+        type: "depends-on",
+      });
+    });
+
+    it("should generate graph with constraint relationships", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({ id: "rule1", description: "Rule 1", impl: () => [] })
+      );
+      registry.registerConstraint(
+        defineConstraint({
+          id: "c1",
+          description: "Constrains rule1",
+          impl: () => true,
+          meta: { constrains: "rule1" },
+        })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const graph = introspector.generateGraph();
+
+      expect(graph.edges).toHaveLength(1);
+      expect(graph.edges[0]).toEqual({
+        from: "c1",
+        to: "rule1",
+        type: "constrains",
+      });
+    });
+
+    it("should export DOT format", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({ id: "rule1", description: "Rule 1", impl: () => [] })
+      );
+      registry.registerConstraint(
+        defineConstraint({ id: "c1", description: "Constraint 1", impl: () => true })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const dot = introspector.exportDOT();
+
+      expect(dot).toContain("digraph PraxisRegistry");
+      expect(dot).toContain('"rule1"');
+      expect(dot).toContain('"c1"');
+      expect(dot).toContain("shape=box");
+      expect(dot).toContain("shape=diamond");
+    });
+
+    it("should export Mermaid format", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({ id: "rule1", description: "Rule 1", impl: () => [] })
+      );
+      registry.registerConstraint(
+        defineConstraint({ id: "c1", description: "Constraint 1", impl: () => true })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+      const mermaid = introspector.exportMermaid();
+
+      expect(mermaid).toContain("graph TB");
+      expect(mermaid).toContain("rule1");
+      expect(mermaid).toContain("c1");
+    });
+
+    it("should get rule info", () => {
+      const rule = defineRule({
+        id: "test.rule",
+        description: "Test rule",
+        impl: () => [],
+        meta: { version: "1.0.0" },
+      });
+
+      const registry = new PraxisRegistry<{ value: number }>();
+      registry.registerRule(rule);
+
+      const introspector = new RegistryIntrospector(registry);
+      const info = introspector.getRuleInfo("test.rule");
+
+      expect(info).toBeDefined();
+      expect(info?.id).toBe("test.rule");
+      expect(info?.description).toBe("Test rule");
+      expect(info?.meta).toEqual({ version: "1.0.0" });
+    });
+
+    it("should get constraint info", () => {
+      const constraint = defineConstraint({
+        id: "test.constraint",
+        description: "Test constraint",
+        impl: () => true,
+        meta: { severity: "error" },
+      });
+
+      const registry = new PraxisRegistry<{ value: number }>();
+      registry.registerConstraint(constraint);
+
+      const introspector = new RegistryIntrospector(registry);
+      const info = introspector.getConstraintInfo("test.constraint");
+
+      expect(info).toBeDefined();
+      expect(info?.id).toBe("test.constraint");
+      expect(info?.description).toBe("Test constraint");
+      expect(info?.meta).toEqual({ severity: "error" });
+    });
+
+    it("should search rules by query", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerRule(
+        defineRule({ id: "auth.login", description: "Login rule", impl: () => [] })
+      );
+      registry.registerRule(
+        defineRule({ id: "auth.logout", description: "Logout rule", impl: () => [] })
+      );
+      registry.registerRule(
+        defineRule({ id: "cart.add", description: "Add to cart", impl: () => [] })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+
+      const authRules = introspector.searchRules("auth");
+      expect(authRules).toHaveLength(2);
+
+      const loginRules = introspector.searchRules("login");
+      expect(loginRules).toHaveLength(1);
+      expect(loginRules[0]?.id).toBe("auth.login");
+
+      const cartRules = introspector.searchRules("cart");
+      expect(cartRules).toHaveLength(1);
+    });
+
+    it("should search constraints by query", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+
+      registry.registerConstraint(
+        defineConstraint({ id: "auth.maxSessions", description: "Max sessions", impl: () => true })
+      );
+      registry.registerConstraint(
+        defineConstraint({ id: "cart.maxItems", description: "Max items in cart", impl: () => true })
+      );
+
+      const introspector = new RegistryIntrospector(registry);
+
+      const authConstraints = introspector.searchConstraints("auth");
+      expect(authConstraints).toHaveLength(1);
+      expect(authConstraints[0]?.id).toBe("auth.maxSessions");
+
+      const maxConstraints = introspector.searchConstraints("max");
+      expect(maxConstraints).toHaveLength(2);
+    });
+
+    it("should work with empty registry", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+      const introspector = new RegistryIntrospector(registry);
+
+      const stats = introspector.getStats();
+      expect(stats.ruleCount).toBe(0);
+      expect(stats.constraintCount).toBe(0);
+
+      const graph = introspector.generateGraph();
+      expect(graph.nodes).toHaveLength(0);
+      expect(graph.edges).toHaveLength(0);
+
+      const schema = introspector.generateSchema("1.0.0");
+      expect(schema.rules).toHaveLength(0);
+      expect(schema.constraints).toHaveLength(0);
+    });
+
+    it("should work with modules", () => {
+      const module = defineModule({
+        rules: [
+          defineRule({ id: "m1.rule1", description: "Module rule 1", impl: () => [] }),
+          defineRule({ id: "m1.rule2", description: "Module rule 2", impl: () => [] }),
+        ],
+        constraints: [
+          defineConstraint({ id: "m1.c1", description: "Module constraint 1", impl: () => true }),
+        ],
+        meta: { moduleName: "Module 1" },
+      });
+
+      const registry = new PraxisRegistry<{ value: number }>();
+      registry.registerModule(module);
+
+      const introspector = new RegistryIntrospector(registry);
+      const stats = introspector.getStats();
+
+      expect(stats.ruleCount).toBe(2);
+      expect(stats.constraintCount).toBe(1);
+    });
+  });
+
+  describe("createIntrospector", () => {
+    it("should create introspector from registry", () => {
+      const registry = new PraxisRegistry<{ value: number }>();
+      const introspector = createIntrospector(registry);
+
+      expect(introspector).toBeInstanceOf(RegistryIntrospector);
+    });
+  });
+});

package/src/__tests__/protocol.test.ts

@@ -0,0 +1,40 @@
+/**
+ * Core protocol tests
+ */
+
+import { describe, it, expect } from "vitest";
+import type { PraxisFact, PraxisEvent, PraxisState } from "../core/protocol.js";
+
+describe("Protocol Types", () => {
+  it("should create a valid fact", () => {
+    const fact: PraxisFact = {
+      tag: "TestFact",
+      payload: { value: 42 },
+    };
+
+    expect(fact.tag).toBe("TestFact");
+    expect(fact.payload).toEqual({ value: 42 });
+  });
+
+  it("should create a valid event", () => {
+    const event: PraxisEvent = {
+      tag: "TEST_EVENT",
+      payload: { action: "test" },
+    };
+
+    expect(event.tag).toBe("TEST_EVENT");
+    expect(event.payload).toEqual({ action: "test" });
+  });
+
+  it("should create a valid state", () => {
+    const state: PraxisState = {
+      context: { count: 0 },
+      facts: [{ tag: "CountInitialized", payload: {} }],
+      meta: { version: "1.0.0" },
+    };
+
+    expect(state.context).toEqual({ count: 0 });
+    expect(state.facts).toHaveLength(1);
+    expect(state.meta?.version).toBe("1.0.0");
+  });
+});