dzql 0.6.3 → 0.6.6

package/tests/compiler.test.ts

@@ -1,45 +0,0 @@
-import { describe, test, expect } from "bun:test";
-import { analyzeDomain } from "../src/cli/compiler/analyzer.js";
-
-// Mock domain for testing
-const validDomain = {
-  entities: {
-    users: { schema: { id: "serial primary key" } },
-    posts: { schema: { id: "serial primary key", user_id: "int" } }
-  },
-  subscribables: {
-    user_posts: {
-      root: { entity: "users" },
-      includes: {
-        posts: { entity: "posts" }
-      }
-    }
-  }
-};
-
-const invalidDomain = {
-  entities: {
-    users: { schema: { id: "serial primary key" } }
-  },
-  subscribables: {
-    broken_feed: {
-      root: { entity: "users" },
-      includes: {
-        posts: { entity: "missing_posts" } // <--- Reference to missing entity
-      }
-    }
-  }
-};
-
-describe("Compiler Analyzer", () => {
-  test("should pass for valid domain", () => {
-    const errors = analyzeDomain(validDomain);
-    expect(errors).toHaveLength(0);
-  });
-
-  test("should fail for missing entity reference", () => {
-    const errors = analyzeDomain(invalidDomain);
-    expect(errors).toHaveLength(1);
-    expect(errors[0]).toContain("references unknown entity 'missing_posts'");
-  });
-});

package/tests/graph_rules.test.ts

@@ -1,173 +0,0 @@
-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

@@ -1,174 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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'");
-  });
-});