@plures/praxis 1.0.3 → 1.1.1

package/src/__tests__/engine.test.ts

@@ -2,13 +2,13 @@
  * Engine tests
  */
 
-import { describe, it, expect } from "vitest";
-import { createPraxisEngine } from "../core/engine.js";
-import { PraxisRegistry } from "../core/rules.js";
-import { defineRule, defineConstraint, defineFact, defineEvent } from "../dsl/index.js";
+import { describe, it, expect } from 'vitest';
+import { createPraxisEngine } from '../core/engine.js';
+import { PraxisRegistry } from '../core/rules.js';
+import { defineRule, defineConstraint, defineFact, defineEvent } from '../dsl/index.js';
 
-describe("LogicEngine", () => {
-  it("should create an engine with initial context", () => {
+describe('LogicEngine', () => {
+  it('should create an engine with initial context', () => {
     const registry = new PraxisRegistry<{ count: number }>();
     const engine = createPraxisEngine({
       initialContext: { count: 0 },
@@ -18,17 +18,17 @@ describe("LogicEngine", () => {
     expect(engine.getContext()).toEqual({ count: 0 });
   });
 
-  it("should apply rules when processing events", () => {
+  it('should apply rules when processing events', () => {
     interface Context {
       count: number;
     }
 
-    const Incremented = defineFact<"Incremented", { amount: number }>("Incremented");
-    const Increment = defineEvent<"INCREMENT", {}>("INCREMENT");
+    const Incremented = defineFact<'Incremented', { amount: number }>('Incremented');
+    const Increment = defineEvent<'INCREMENT', {}>('INCREMENT');
 
     const incrementRule = defineRule<Context>({
-      id: "increment",
-      description: "Increment counter",
+      id: 'increment',
+      description: 'Increment counter',
       impl: (state, events) => {
         if (events.some(Increment.is)) {
           state.context.count += 1;
@@ -50,19 +50,19 @@ describe("LogicEngine", () => {
 
     expect(engine.getContext().count).toBe(1);
     expect(result.state.facts).toHaveLength(1);
-    expect(result.state.facts[0]?.tag).toBe("Incremented");
+    expect(result.state.facts[0]?.tag).toBe('Incremented');
   });
 
-  it("should check constraints", () => {
+  it('should check constraints', () => {
     interface Context {
       count: number;
     }
 
     const maxConstraint = defineConstraint<Context>({
-      id: "max100",
-      description: "Count cannot exceed 100",
+      id: 'max100',
+      description: 'Count cannot exceed 100',
       impl: (state) => {
-        return state.context.count <= 100 || "Count exceeds 100";
+        return state.context.count <= 100 || 'Count exceeds 100';
       },
     });
 
@@ -82,21 +82,21 @@ describe("LogicEngine", () => {
     engine.updateContext(() => ({ count: 150 }));
     result = engine.step([]);
     expect(result.diagnostics).toHaveLength(1);
-    expect(result.diagnostics[0]?.kind).toBe("constraint-violation");
+    expect(result.diagnostics[0]?.kind).toBe('constraint-violation');
   });
 
-  it("should handle multiple rules", () => {
+  it('should handle multiple rules', () => {
     interface Context {
       value: number;
     }
 
-    const Doubled = defineFact<"Doubled", {}>("Doubled");
-    const Added = defineFact<"Added", { amount: number }>("Added");
-    const DoubleThenAdd = defineEvent<"DOUBLE_ADD", { amount: number }>("DOUBLE_ADD");
+    const Doubled = defineFact<'Doubled', {}>('Doubled');
+    const Added = defineFact<'Added', { amount: number }>('Added');
+    const DoubleThenAdd = defineEvent<'DOUBLE_ADD', { amount: number }>('DOUBLE_ADD');
 
     const doubleRule = defineRule<Context>({
-      id: "double",
-      description: "Double the value",
+      id: 'double',
+      description: 'Double the value',
       impl: (state, events) => {
         if (events.some(DoubleThenAdd.is)) {
           state.context.value *= 2;
@@ -107,8 +107,8 @@ describe("LogicEngine", () => {
     });
 
     const addRule = defineRule<Context>({
-      id: "add",
-      description: "Add to the value",
+      id: 'add',
+      description: 'Add to the value',
       impl: (state, events) => {
         const event = events.find(DoubleThenAdd.is);
         if (event) {
@@ -134,4 +134,30 @@ describe("LogicEngine", () => {
     expect(engine.getContext().value).toBe(25);
     expect(result.state.facts).toHaveLength(2);
   });
+
+  it('should safely clone state when context contains non-structured-clone values', () => {
+    const registry = new PraxisRegistry<{ fn: () => number; timer: any; value: number }>();
+
+    // Context includes a function and a timer handle (non-structured-clone-able)
+    const timer = setTimeout(() => {}, 0);
+    const initialContext = {
+      fn: () => 42,
+      timer,
+      value: 1,
+    };
+
+    const engine = createPraxisEngine({
+      initialContext,
+      registry,
+    });
+
+    clearTimeout(timer);
+
+    expect(() => engine.getContext()).not.toThrow();
+    expect(() => engine.getState()).not.toThrow();
+
+    const ctx = engine.getContext();
+    expect(typeof ctx.fn).toBe('function');
+    expect(ctx.value).toBe(1);
+  });
 });

package/src/__tests__/generators.test.ts

@@ -50,24 +50,24 @@ describe('Code Generators', () => {
     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');
+      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');
-      
+      const factsFile = files.find((f) => f.type === 'facts');
+
       expect(factsFile).toBeDefined();
       expect(factsFile?.content).toContain('UserCreated');
       expect(factsFile?.content).toContain('defineFact');
@@ -77,10 +77,10 @@ describe('Code Generators', () => {
     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');
-      
+      const eventsFile = files.find((f) => f.type === 'events');
+
       expect(eventsFile).toBeDefined();
       expect(eventsFile?.content).toContain('CREATE_USER');
       expect(eventsFile?.content).toContain('defineEvent');
@@ -91,10 +91,10 @@ describe('Code Generators', () => {
     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');
-      
+      const engineFile = files.find((f) => f.type === 'engine');
+
       expect(engineFile).toBeDefined();
       expect(engineFile?.content).toContain('interface User');
       expect(engineFile?.content).toContain('id: string');
@@ -111,9 +111,9 @@ describe('Code Generators', () => {
         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);
@@ -123,10 +123,10 @@ describe('Code Generators', () => {
       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');
-      
+      const componentFile = result.files.find((f) => f.type === 'component');
+
       expect(componentFile).toBeDefined();
       expect(componentFile?.content).toContain('<form');
       expect(componentFile?.content).toContain('input');
@@ -141,10 +141,10 @@ describe('Code Generators', () => {
       const generator = createComponentGenerator('/tmp/test', {
         typescript: true,
       });
-      
+
       const result = generator.generateComponent(component, model);
-      const typesFile = result.files.find(f => f.type === 'types');
-      
+      const typesFile = result.files.find((f) => f.type === 'types');
+
       expect(typesFile).toBeDefined();
       expect(typesFile?.content).toContain('interface User');
     });
@@ -155,10 +155,10 @@ describe('Code Generators', () => {
       const generator = createComponentGenerator('/tmp/test', {
         includeDocs: true,
       });
-      
+
       const result = generator.generateComponent(component, model);
-      const docsFile = result.files.find(f => f.type === 'docs');
-      
+      const docsFile = result.files.find((f) => f.type === 'docs');
+
       expect(docsFile).toBeDefined();
       expect(docsFile?.content).toContain('# UserForm');
     });
@@ -168,9 +168,9 @@ describe('Code Generators', () => {
     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');
     });
@@ -178,10 +178,10 @@ describe('Code Generators', () => {
     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:');
@@ -192,10 +192,10 @@ describe('Code Generators', () => {
       const generator = createPluresDBGenerator('/tmp/test', {
         dbName: 'custom-db',
       });
-      
+
       const files = generator.generateConfig(normalized);
       const configFile = files[0];
-      
+
       expect(configFile.content).toContain("name: 'custom-db'");
     });
 
@@ -205,10 +205,10 @@ describe('Code Generators', () => {
         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');
@@ -219,10 +219,10 @@ describe('Code Generators', () => {
       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');
@@ -234,9 +234,7 @@ describe('Code Generators', () => {
         models: [
           {
             ...testSchema.models![0],
-            indexes: [
-              { name: 'email_idx', fields: ['email'] },
-            ],
+            indexes: [{ name: 'email_idx', fields: ['email'] }],
           },
         ],
       };
@@ -244,10 +242,10 @@ describe('Code Generators', () => {
       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');
@@ -258,10 +256,10 @@ describe('Code Generators', () => {
       const generator = createPluresDBGenerator('/tmp/test', {
         autoIndex: 'none',
       });
-      
+
       const files = generator.generateConfig(normalized);
       const configFile = files[0];
-      
+
       // 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)