dzql 0.5.33 → 0.6.1

package/tests/graph_rules.test.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect } from "bun:test";
+import { compileGraphRules } from "../src/cli/compiler/graph_rules.js";
+import type { GraphRuleIR } from "../src/shared/ir.js";
+
+// Mock entity graph rules in IR format
+const mockGraphRules = {
+  onCreate: [
+    {
+      trigger: 'create' as const,
+      action: 'reactor' as const,
+      target: 'notify_subscribers',
+      params: { post_id: '@id' }
+    }
+  ] as GraphRuleIR[],
+  onDelete: [
+    {
+      trigger: 'delete' as const,
+      action: 'delete' as const,
+      target: 'comments',
+      params: { post_id: '@id' }
+    }
+  ] as GraphRuleIR[]
+};
+
+describe("Graph Rules Compiler", () => {
+
+  test("should compile reactor to event insertion", () => {
+    // Should insert into dzql_v2.events with op='reactor:notify_subscribers'
+    const sql = compileGraphRules('posts', 'create', mockGraphRules.onCreate);
+
+    expect(sql).toContain("INSERT INTO dzql_v2.events");
+    expect(sql).toContain("'reactor:notify_subscribers'");
+    // Simply check for the variable resolution logic
+    expect(sql).toContain("v_result->>'id'");
+  });
+
+  test("should compile delete action to SQL delete", () => {
+    // Should generate DELETE FROM comments ...
+    const sql = compileGraphRules('posts', 'delete', mockGraphRules.onDelete);
+
+    expect(sql).toContain("DELETE FROM comments");
+    expect(sql).toContain("post_id = (v_old_data->>'id')::int"); // Variable resolution from old record
+  });
+
+  test("should compile create action with field defaults", () => {
+    const rules: GraphRuleIR[] = [{
+      trigger: 'create',
+      action: 'create',
+      target: 'memberships',
+      params: { user_id: '@user_id', org_id: '@id', valid_from: '@today' }
+    }];
+
+    const sql = compileGraphRules('organisations', 'create', rules);
+
+    expect(sql).toContain("INSERT INTO memberships");
+    expect(sql).toContain("user_id, org_id, valid_from");
+    expect(sql).toContain("p_user_id");
+    expect(sql).toContain("(v_result->>'id')::int");
+    expect(sql).toContain("CURRENT_DATE");
+  });
+
+  test("should compile update action with match clause", () => {
+    const rules: GraphRuleIR[] = [{
+      trigger: 'update',
+      action: 'update',
+      target: 'audit_log',
+      params: { last_modified: '@now' },
+      match: { entity_id: '@id' }
+    }];
+
+    const sql = compileGraphRules('posts', 'update', rules);
+
+    expect(sql).toContain("UPDATE audit_log");
+    expect(sql).toContain("SET last_modified = NOW()");
+    expect(sql).toContain("WHERE entity_id = (v_result->>'id')::int");
+  });
+
+  test("should compile validate action", () => {
+    const rules: GraphRuleIR[] = [{
+      trigger: 'create',
+      action: 'validate',
+      target: 'check_quota',
+      params: { user_id: '@user_id' },
+      error_message: 'Quota exceeded'
+    }];
+
+    const sql = compileGraphRules('posts', 'create', rules);
+
+    expect(sql).toContain("IF NOT check_quota(");
+    expect(sql).toContain("user_id => p_user_id");
+    expect(sql).toContain("RAISE EXCEPTION 'Quota exceeded'");
+  });
+
+  test("should compile execute action", () => {
+    const rules: GraphRuleIR[] = [{
+      trigger: 'create',
+      action: 'execute',
+      target: 'send_notification',
+      params: { post_id: '@id', author_id: '@author_id' }
+    }];
+
+    const sql = compileGraphRules('posts', 'create', rules);
+
+    expect(sql).toContain("PERFORM send_notification(");
+    expect(sql).toContain("post_id => (v_result->>'id')");
+    expect(sql).toContain("author_id => (v_result->>'author_id')");
+  });
+
+  test("should compile conditional rule with @before/@after", () => {
+    const rules: GraphRuleIR[] = [{
+      trigger: 'update',
+      action: 'reactor',
+      target: 'status_changed',
+      condition: "@before.status = 'draft' AND @after.status = 'published'",
+      params: { post_id: '@id' }
+    }];
+
+    const sql = compileGraphRules('posts', 'update', rules);
+
+    expect(sql).toContain("-- Condition:");
+    expect(sql).toContain("IF (v_old_data->>'status') = 'draft' AND (v_result->>'status') = 'published' THEN");
+    expect(sql).toContain("INSERT INTO dzql_v2.events");
+    expect(sql).toContain("END IF;");
+  });
+
+  test("should resolve @before variables in delete trigger", () => {
+    const rules: GraphRuleIR[] = [{
+      trigger: 'delete',
+      action: 'execute',
+      target: 'archive_post',
+      params: { title: '@before.title', author_id: '@before.author_id' }
+    }];
+
+    const sql = compileGraphRules('posts', 'delete', rules);
+
+    expect(sql).toContain("PERFORM archive_post(");
+    expect(sql).toContain("title => (v_old_data->>'title')");
+    // Note: execute/validate params don't get ::int cast - they're named parameters
+    expect(sql).toContain("author_id => (v_old_data->>'author_id')");
+  });
+
+  test("should handle multiple actions", () => {
+    const rules: GraphRuleIR[] = [
+      {
+        trigger: 'create',
+        action: 'validate',
+        target: 'check_permissions',
+        params: { user_id: '@user_id' },
+        error_message: 'Not allowed'
+      },
+      {
+        trigger: 'create',
+        action: 'create',
+        target: 'audit_log',
+        params: { entity_id: '@id', action: 'created' }
+      },
+      {
+        trigger: 'create',
+        action: 'reactor',
+        target: 'notify_admins',
+        params: { post_id: '@id' }
+      }
+    ];
+
+    const sql = compileGraphRules('posts', 'create', rules);
+
+    // Should have all three actions
+    expect(sql).toContain("IF NOT check_permissions");
+    expect(sql).toContain("INSERT INTO audit_log");
+    expect(sql).toContain("reactor:notify_admins");
+  });
+
+});

package/tests/integration/db.test.ts

@@ -0,0 +1,174 @@
+import { describe, test, expect, beforeAll, afterAll } from "bun:test";
+import { V2TestDatabase } from "./setup.js";
+import { generateCoreSQL, generateEntitySQL, generateSchemaSQL } from "../../src/cli/codegen/sql.js";
+import { generateIR } from "../../src/cli/compiler/ir.js";
+import { entities } from "../../examples/blog.js";
+
+const blogDomain = { entities, subscribables: {} };
+
+describe("V2 Database Integration (Real Postgres)", () => {
+  let db: V2TestDatabase;
+  let sql: any;
+
+  beforeAll(async () => {
+    db = new V2TestDatabase();
+    // This connects to localhost:5433 by default (from setup.ts)
+    sql = await db.setup();
+
+    try {
+      // 1. Generate SQL
+      const ir = generateIR(blogDomain);
+      const coreSQL = generateCoreSQL();
+      const postsSchema = generateSchemaSQL("posts", ir.entities.posts);
+      const commentsSchema = generateSchemaSQL("comments", ir.entities.comments);
+      const postsSQL = generateEntitySQL("posts", ir.entities.posts);
+      const commentsSQL = generateEntitySQL("comments", ir.entities.comments);
+
+      // 2. Apply SQL to the real DB
+      await db.applySQL(coreSQL);
+      await db.applySQL(postsSchema);
+      await db.applySQL(commentsSchema);
+      await db.applySQL(postsSQL);
+      await db.applySQL(commentsSQL);
+    } catch (e) {
+      console.error("Setup failed:", e);
+      throw e;
+    }
+  });
+
+  afterAll(async () => {
+    await db.teardown();
+  });
+
+  test("should save a post via compiled function (Atomic Upsert)", async () => {
+    const userId = 1;
+    const postData = { id: 1, title: "Real DB Test", content: "It works!", author_id: 1 };
+
+    // Call the compiled PL/pgSQL function
+    const result = await sql`
+      SELECT dzql_v2.save_posts(${userId}, ${sql.json(postData)}) as data
+    `;
+
+    const saved = result[0].data;
+    expect(saved.id).toBe(1);
+    expect(saved.title).toBe("Real DB Test");
+    
+    // Verify persistence
+    const rows = await sql`SELECT * FROM posts WHERE id = 1`;
+    expect(rows.length).toBe(1);
+    expect(rows[0].title).toBe("Real DB Test");
+  });
+
+  test("should enforce permissions (Inlined SQL)", async () => {
+    const hackerId = 2; 
+    const postData = { id: 2, title: "Hacked", content: "Bad", author_id: 1 };
+
+    // Should fail because @author_id (1) != @user_id (2)
+    try {
+      await sql`
+        SELECT dzql_v2.save_posts(${hackerId}, ${sql.json(postData)})
+      `;
+      expect(true).toBe(false); // Should not fail
+    } catch (e: any) {
+      expect(e.message).toContain("permission_denied");
+    }
+  });
+
+  test("should emit normalized row events (Commit Batching)", async () => {
+    // We expect the 'insert' from the first test to be in the events table
+    const events = await sql`
+      SELECT * FROM dzql_v2.events 
+      WHERE table_name = 'posts' 
+      ORDER BY id DESC LIMIT 1
+    `;
+    
+    expect(events.length).toBe(1);
+    expect(events[0].op).toBe("insert");
+    expect(events[0].data.title).toBe("Real DB Test");
+    expect(events[0].old_data).toBeNull(); // Insert has no old data
+    expect(events[0].commit_id).toBeDefined(); // Ensure commit ID was generated
+  });
+
+  test("should populate old_data on update", async () => {
+    const userId = 1;
+    // Update the existing post (id: 1)
+    const updateData = { id: 1, title: "Updated Title" };
+    
+    await sql`
+      SELECT dzql_v2.save_posts(${userId}, ${sql.json(updateData)})
+    `;
+
+    const events = await sql`
+      SELECT * FROM dzql_v2.events 
+      WHERE table_name = 'posts' AND op = 'update'
+      ORDER BY id DESC LIMIT 1
+    `;
+
+    expect(events.length).toBe(1);
+    expect(events[0].op).toBe("update");
+    expect(events[0].data.title).toBe("Updated Title");
+    expect(events[0].old_data).not.toBeNull();
+    expect(events[0].old_data.title).toBe("Real DB Test"); // Previous title
+  });
+  
+  test("should trigger reactors (Graph Rules)", async () => {
+    // The blog.ts example has a reactor 'notify_subscribers' on create
+    const reactorEvents = await sql`
+      SELECT * FROM dzql_v2.events 
+      WHERE op LIKE 'reactor:%'
+      ORDER BY id DESC LIMIT 1
+    `;
+    
+    expect(reactorEvents.length).toBe(1);
+    expect(reactorEvents[0].op).toBe("reactor:notify_subscribers");
+    expect(reactorEvents[0].data.post_id).toBe("1");
+  });
+
+  test("should delete a post via compiled function (Atomic Delete)", async () => {
+    const userId = 1;
+    // Call the compiled PL/pgSQL function
+    const result = await sql`
+      SELECT dzql_v2.delete_posts(${userId}, ${sql.json({ id: 1 })}) as data
+    `;
+
+    const deleted = result[0].data;
+    expect(deleted.id).toBe(1);
+    
+    // Verify gone
+    const rows = await sql`SELECT * FROM posts WHERE id = 1`;
+    expect(rows.length).toBe(0);
+
+    // Verify Event
+    const events = await sql`
+      SELECT * FROM dzql_v2.events 
+      WHERE table_name = 'posts' AND op = 'delete'
+      ORDER BY id DESC LIMIT 1
+    `;
+    expect(events.length).toBe(1);
+    expect(events[0].pk.id).toBe(1);
+  });
+
+  test("should get a post via compiled function", async () => {
+    // Re-create post first
+    await sql`INSERT INTO posts (id, title, author_id) VALUES (100, 'Get Test', 1)`;
+    
+    const userId = 1;
+    const result = await sql`
+      SELECT dzql_v2.get_posts(${userId}, ${sql.json({ id: 100 })}) as data
+    `;
+    
+    expect(result[0].data.title).toBe("Get Test");
+  });
+
+  test("should search posts via compiled function", async () => {
+    // Search
+    const userId = 1;
+    const result = await sql`
+      SELECT dzql_v2.search_posts(${userId}, ${sql.json({ limit: 5 })}) as data
+    `;
+    
+    expect(result[0].data).toBeArray();
+    expect(result[0].data.length).toBeGreaterThan(0);
+    expect(result[0].data[0].title).toBe("Get Test");
+  });
+});

package/tests/integration/e2e.test.ts

@@ -0,0 +1,65 @@
+import { describe, test, expect, beforeAll } from "bun:test";
+import { generateCoreSQL, generateEntitySQL } from "../../src/cli/codegen/sql.js";
+import { generateIR } from "../../src/cli/compiler/ir.js";
+
+// Load our blog example directly (bypassing loader for test isolation)
+import { entities } from "../../examples/blog.js";
+
+const blogDomain = { entities, subscribables: {} };
+
+describe("V2 End-to-End Compiler Integration", () => {
+  let ir: any;
+  let coreSQL: string;
+  let postsSQL: string;
+  let commentsSQL: string;
+
+  beforeAll(() => {
+    // 1. Generate IR from Domain Object
+    ir = generateIR(blogDomain);
+    
+    // 2. Generate SQL
+    coreSQL = generateCoreSQL();
+    postsSQL = generateEntitySQL("posts", ir.entities.posts);
+    commentsSQL = generateEntitySQL("comments", ir.entities.comments);
+  });
+
+  test("should generate valid IR for blog", () => {
+    expect(ir.entities.posts).toBeDefined();
+    expect(ir.entities.posts.primaryKey).toEqual(["id"]);
+    // Check permission parsing
+    expect(ir.entities.posts.permissions.create).toEqual(['@author_id == @user_id']);
+  });
+
+  test("should generate core SQL schema", () => {
+    expect(coreSQL).toContain("CREATE SCHEMA IF NOT EXISTS dzql_v2");
+    expect(coreSQL).toContain("CREATE TABLE IF NOT EXISTS dzql_v2.events");
+  });
+
+  test("should generate atomic UPSERT for posts", () => {
+    // Check function signature
+    expect(postsSQL).toContain("CREATE OR REPLACE FUNCTION dzql_v2.save_posts");
+    
+    // Check security
+    expect(postsSQL).toContain("SECURITY DEFINER");
+    expect(postsSQL).toContain("SET search_path = dzql_v2, public");
+    
+    // Check Update/Insert Branching (New V2 Pattern with composite PK support)
+    expect(postsSQL).toContain("AND EXISTS(SELECT 1 FROM posts WHERE");
+    expect(postsSQL).toContain("UPDATE posts SET");
+    expect(postsSQL).toContain("INSERT INTO posts");
+    
+    // Check column handling in update
+    expect(postsSQL).toContain("title = CASE WHEN (p_data ? 'title')");
+  });
+
+  test("should inline permission checks", () => {
+    // Check that @author_id == @user_id was compiled correctly
+    expect(postsSQL).toContain("IF NOT ((p_data->>'author_id')::int = p_user_id) THEN"); 
+  });
+
+  test("should compile graph rules", () => {
+    // Check reactor trigger
+    expect(postsSQL).toContain("INSERT INTO dzql_v2.events");
+    expect(postsSQL).toContain("'reactor:notify_subscribers'");
+  });
+});