dzql 0.6.13 → 0.6.15

package/src/cli/codegen/subscribable_sql.ts

@@ -292,7 +292,7 @@ ${paramExtracts}
 
   -- Return data with embedded schema for atomic updates
   RETURN jsonb_build_object(
-    '${sub.root.entity}', v_data,
+    'data', jsonb_build_object('${sub.root.entity}', v_data),
     'schema', '${schemaJson}'::jsonb
   );
 END;
@@ -512,42 +512,78 @@ function generateNestedSelects(
 function generateAffectedKeysFunction(name: string, sub: SubscribableIR): string {
   const cases: string[] = [];
   const paramKey = sub.root.key;
+  const hasParams = Object.keys(sub.params).length > 0;
 
   // Root entity case
-  cases.push(`    WHEN '${sub.root.entity}' THEN
+  // For subscribables with no params (list feeds), just return the subscribable name
+  // For subscribables with params, include the root entity's id
+  if (hasParams) {
+    cases.push(`    WHEN '${sub.root.entity}' THEN
       RETURN ARRAY['${name}:' || (p_data->>'id')];`);
+  } else {
+    cases.push(`    WHEN '${sub.root.entity}' THEN
+      RETURN ARRAY['${name}'];`);
+  }
 
   // Get singular form of root entity for FK fields
   const singularRootEntity = singularize(sub.root.entity);
 
   // Related entity cases
+  // Track FK relationships: parentEntity -> { childEntity: { fkOnParent, fkOnChild } }
+  const relationships: Record<string, Record<string, { fkOnParent: string }>> = {};
+
   const addRelationCase = (relName: string, relConfig: IncludeIR, parentEntity: string) => {
     const relEntity = relConfig.entity;
     const filter = relConfig.filter || {};
 
-    // Find the FK field that points to root (use singular form)
-    let fkField = `${singularRootEntity}_id`;
+    // Find the FK field on parent that points to child
+    // For includes like `org: 'organisations'`, the FK is `org_id` on the parent
+    // For includes like `{ entity: 'comments', filter: { post_id: '@id' } }`, the FK is on child
+    let fkOnParent = `${relName}_id`; // Default: relation name + _id (e.g., org -> org_id)
+
+    // Check if filter references @id - if so, the FK is on the child pointing to parent
+    let fkOnChild: string | null = null;
     for (const [field, value] of Object.entries(filter)) {
       if (value === '@id' || value === `@${paramKey}`) {
-        fkField = field;
+        fkOnChild = field; // e.g., user_id, venue_id
         break;
       }
     }
 
-    const singularParent = singularize(parentEntity);
+    // Store relationship for nested lookups
+    if (!relationships[parentEntity]) relationships[parentEntity] = {};
+    relationships[parentEntity][relEntity] = { fkOnParent };
 
-    // For nested relations, we need to traverse up
+    // For nested relations, we need to traverse up via the FK on parent
     if (parentEntity !== sub.root.entity) {
-      cases.push(`    WHEN '${relEntity}' THEN
-      -- Nested: traverse via ${parentEntity}
+      // Get the FK that parent uses to reference this child entity
+      const parentRel = relationships[parentEntity]?.[relEntity];
+      const fkField = parentRel?.fkOnParent || `${relName}_id`;
+
+      if (hasParams) {
+        cases.push(`    WHEN '${relEntity}' THEN
+      -- Nested: traverse via ${parentEntity}.${fkField}
       SELECT ARRAY_AGG('${name}:' || parent.${singularRootEntity}_id)
       INTO v_keys
       FROM ${parentEntity} parent
-      WHERE parent.id = (p_data->>'${singularParent}_id')::int;
+      WHERE parent.${fkField} = (p_data->>'id')::int;
       RETURN COALESCE(v_keys, ARRAY[]::text[]);`);
+      } else {
+        // No params - just return the subscribable name
+        cases.push(`    WHEN '${relEntity}' THEN
+      RETURN ARRAY['${name}'];`);
+      }
     } else {
-      cases.push(`    WHEN '${relEntity}' THEN
-      RETURN ARRAY['${name}:' || (p_data->>'${fkField}')];`);
+      // Direct child of root - use the FK on child that points to root
+      const keyField = fkOnChild || `${singularRootEntity}_id`;
+      if (hasParams) {
+        cases.push(`    WHEN '${relEntity}' THEN
+      RETURN ARRAY['${name}:' || (p_data->>'${keyField}')];`);
+      } else {
+        // No params - just return the subscribable name
+        cases.push(`    WHEN '${relEntity}' THEN
+      RETURN ARRAY['${name}'];`);
+      }
     }
 
     // Recurse for nested includes
@@ -582,6 +618,47 @@ END;
 $$;`;
 }
 
+/**
+ * Generate the central compute_affected_keys function that aggregates all subscribable affected keys.
+ * This is called from save/delete functions to compute all affected subscription keys at write time.
+ */
+export function generateComputeAffectedKeysFunction(subscribableNames: string[]): string {
+  if (subscribableNames.length === 0) {
+    return `-- No subscribables defined, empty compute_affected_keys function
+CREATE OR REPLACE FUNCTION dzql_v2.compute_affected_keys(
+  p_table TEXT,
+  p_op TEXT,
+  p_data JSONB
+) RETURNS TEXT[]
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+BEGIN
+  RETURN ARRAY[]::text[];
+END;
+$$;`;
+  }
+
+  const calls = subscribableNames.map(name =>
+    `dzql_v2.${name}_affected_keys(p_table, p_op, p_data)`
+  ).join(' || ');
+
+  return `-- Central function to compute all affected subscription keys
+-- Called from save/delete functions at write time
+CREATE OR REPLACE FUNCTION dzql_v2.compute_affected_keys(
+  p_table TEXT,
+  p_op TEXT,
+  p_data JSONB
+) RETURNS TEXT[]
+LANGUAGE plpgsql
+IMMUTABLE
+AS $$
+BEGIN
+  RETURN ${calls};
+END;
+$$;`;
+}
+
 function buildPathMapping(
   rootEntity: string,
   includes: Record<string, IncludeIR>,

package/src/cli/codegen/subscribable_store.ts

@@ -1,5 +1,4 @@
 import { Manifest } from "./manifest.js";
-import { SubscribableIR, IncludeIR } from "../../shared/ir.js";
 
 function toPascalCase(str: string): string {
   return str.replace(/(^|_)([a-z])/g, (g) => g[g.length - 1].toUpperCase());
@@ -12,6 +11,8 @@ export function generateSubscribableStore(manifest: Manifest, subName: string):
   }
 
   const pascalName = toPascalCase(subName);
+  const scopeTables = sub.scopeTables || [];
+  const rootEntity = sub.root?.entity || '';
 
   // Generate params interface
   const paramEntries = Object.entries(sub.params);
@@ -26,60 +27,8 @@ export function generateSubscribableStore(manifest: Manifest, subName: string):
       }).join('\n')
     : '  [key: string]: unknown;';
 
-  // Helper to generate patch cases recursively
-  const generatePatchCases = (): string => {
-    const cases: string[] = [];
-
-    // 1. Root Entity
-    cases.push(
-      `      case '${sub.root.entity}':\n` +
-      `        if (event.op === 'update' && doc.${sub.root.entity}) {\n` +
-      `          Object.assign(doc.${sub.root.entity}, event.data);\n` +
-      `        }\n` +
-      `        break;`
-    );
-
-    // 2. Recursive Includes
-    const traverse = (includes: Record<string, IncludeIR>, pathStack: string[]) => {
-      for (const [key, include] of Object.entries(includes)) {
-        const entityName = include.entity;
-
-        if (pathStack.length === 0) {
-          // Level 1
-          cases.push(
-            `      case '${entityName}':\n` +
-            `        handleArrayPatch(doc.${key}, event);\n` +
-            `        break;`
-          );
-        } else {
-          // Level 2+
-          const level1Rel = pathStack[0];
-          const singularParent = level1Rel.endsWith('s') ? level1Rel.slice(0, -1) : level1Rel;
-          const fkField = `${singularParent}_id`;
-
-          cases.push(
-            `      case '${entityName}':\n` +
-            `        if (event.data && (event.data as any).${fkField}) {\n` +
-            `          const parent = (doc.${level1Rel} as any[])?.find((p: any) => p.id === (event.data as any).${fkField});\n` +
-            `          if (parent && parent.${key}) {\n` +
-            `            handleArrayPatch(parent.${key}, event);\n` +
-            `          }\n` +
-            `        }\n` +
-            `        break;`
-          );
-        }
-
-        if (include.includes) {
-          traverse(include.includes, [...pathStack, key]);
-        }
-      }
-    };
-
-    traverse(sub.includes, []);
-    return cases.join('\n');
-  };
-
-  const patchCases = generatePatchCases();
+  // Generate path mappings for atomic updates
+  const pathMappings = sub.includes ? generatePathMappings(rootEntity, sub.includes) : {};
 
   return `// Generated by DZQL Compiler v${manifest.version}
 // Do not edit this file directly.
@@ -93,14 +42,6 @@ export interface ${pascalName}Params {
 ${paramsInterface}
 }
 
-/** Event from server for patching */
-export interface PatchEvent {
-  table: string;
-  op: 'insert' | 'update' | 'delete';
-  pk: { id: number };
-  data: Record<string, unknown> | null;
-}
-
 /** Document wrapper with loading state */
 export interface DocumentWrapper<T> {
   data: T;
@@ -108,9 +49,14 @@ export interface DocumentWrapper<T> {
   ready: Promise<void>;
 }
 
+// Scope tables this subscribable cares about
+const SCOPE_TABLES = ${JSON.stringify(scopeTables)};
+
+// Path mappings: table -> path in document
+const PATH_MAPPINGS: Record<string, string> = ${JSON.stringify(pathMappings)};
+
 export const use${pascalName}Store = defineStore('sub-${subName}', () => {
   const documents: Ref<Record<string, DocumentWrapper<Record<string, unknown>>>> = ref({});
-  const unsubscribers = new Map<string, () => void>();
 
   async function bind(params: ${pascalName}Params): Promise<DocumentWrapper<Record<string, unknown>>> {
     const key = JSON.stringify(params);
@@ -127,58 +73,111 @@ export const use${pascalName}Store = defineStore('sub-${subName}', () => {
     const ready = new Promise<void>((resolve) => { resolveReady = resolve; });
 
     documents.value[key] = { data: {}, loading: true, ready };
-    let isFirst = true;
-
-    const unsubscribe = await ws.api.subscribe_${subName}(params, (eventData: unknown) => {
-      if (isFirst) {
-        // Initial data - merge into existing object to preserve reactivity
-        Object.assign(documents.value[key].data, eventData as Record<string, unknown>);
-        documents.value[key].loading = false;
-        isFirst = false;
-        resolveReady();
-      } else {
-        // Patch event
-        applyPatch(documents.value[key].data, eventData as PatchEvent);
-      }
-    });
 
-    unsubscribers.set(key, unsubscribe as () => void);
-    await ready;
+    // Subscribe to register interest and get initial data
+    // Updates come via broadcasts to table_changed, not via callback
+    const result = await ws.call('subscribe_${subName}', params) as { data: Record<string, unknown>; schema: unknown };
+    Object.assign(documents.value[key].data, result.data);
+    documents.value[key].loading = false;
+    resolveReady();
+
     return documents.value[key];
   }
 
   function unbind(params: ${pascalName}Params): void {
     const key = JSON.stringify(params);
-    const unsubscribe = unsubscribers.get(key);
-    if (unsubscribe) {
-      unsubscribe();
-      unsubscribers.delete(key);
-      delete documents.value[key];
-    }
+    // Unsubscribe to release server-side subscription
+    ws.call('unsubscribe_${subName}', params).catch(() => {});
+    delete documents.value[key];
   }
 
-  function applyPatch(doc: Record<string, unknown>, event: PatchEvent): void {
-    if (!doc) return;
-    switch (event.table) {
-${patchCases}
+  // Broadcast handler - called by global dispatcher
+  function table_changed(table: string, op: string, pk: Record<string, unknown>, data: unknown): void {
+    if (!SCOPE_TABLES.includes(table)) return;
+
+    const path = PATH_MAPPINGS[table];
+
+    // Update all bound documents that might be affected
+    for (const [key, doc] of Object.entries(documents.value)) {
+      if (doc.loading) continue;
+      applyUpdate(doc.data, table, path, op, pk, data);
     }
   }
 
-  function handleArrayPatch(arr: any, event: PatchEvent): void {
-    if (!arr || !Array.isArray(arr)) return;
-    const pkValue = event.pk?.id;
-    const idx = arr.findIndex((i: any) => i?.id === pkValue);
-
-    if (event.op === 'insert') {
-      if (idx === -1 && event.data) arr.push(event.data);
-    } else if (event.op === 'update') {
-      if (idx !== -1 && event.data) Object.assign(arr[idx], event.data);
-    } else if (event.op === 'delete') {
-      if (idx !== -1) arr.splice(idx, 1);
+  function applyUpdate(
+    doc: Record<string, unknown>,
+    table: string,
+    path: string | undefined,
+    op: string,
+    pk: Record<string, unknown>,
+    data: unknown
+  ): void {
+    if (!path) return;
+
+    // Navigate to target
+    const parts = path.split('.');
+    let target: any = doc;
+    for (let i = 0; i < parts.length - 1; i++) {
+      target = target?.[parts[i]];
+      if (!target) return;
+    }
+
+    const key = parts[parts.length - 1];
+    const value = target[key];
+
+    // If target is an object (single entity), update it directly
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      if (op === 'update' && data) {
+        Object.assign(value, data as Record<string, unknown>);
+      }
+      return;
+    }
+
+    // If target is an array, handle insert/update/delete
+    if (Array.isArray(value)) {
+      const pkField = Object.keys(pk)[0] || 'id';
+      const pkValue = pk[pkField];
+      const idx = value.findIndex((item: any) => item?.[pkField] === pkValue);
+
+      switch (op) {
+        case 'insert':
+          if (idx === -1 && data) value.push(data);
+          break;
+        case 'update':
+          if (idx !== -1 && data) Object.assign(value[idx], data);
+          break;
+        case 'delete':
+          if (idx !== -1) value.splice(idx, 1);
+          break;
+      }
     }
   }
 
-  return { bind, unbind, documents };
+  // Self-register with WebSocket for broadcasts
+  ws.registerStore(table_changed);
+
+  return { bind, unbind, documents, table_changed };
 });
 `;
 }
+
+function generatePathMappings(rootEntity: string, includes: Record<string, any>): Record<string, string> {
+  const mappings: Record<string, string> = {};
+  // Root entity is at its own key in the document (e.g., { venues: {...} })
+  mappings[rootEntity] = rootEntity;
+
+  function traverse(inc: Record<string, any>, prefix: string) {
+    for (const [key, value] of Object.entries(inc)) {
+      const entity = typeof value === 'string' ? value : value.entity || key;
+      const path = prefix ? `${prefix}.${key}` : key;
+      mappings[entity] = path;
+
+      if (typeof value === 'object' && value.includes) {
+        traverse(value.includes, path);
+      }
+    }
+  }
+
+  traverse(includes, '');
+  return mappings;
+}

package/src/cli/index.ts

@@ -3,7 +3,7 @@ import { loadDomain } from "./compiler/loader.js";
 import { analyzeDomain } from "./compiler/analyzer.js";
 import { generateIR } from "./compiler/ir.js";
 import { generateCoreSQL, generateEntitySQL, generateSchemaSQL } from "./codegen/sql.js";
-import { generateSubscribableSQL } from "./codegen/subscribable_sql.js";
+import { generateSubscribableSQL, generateComputeAffectedKeysFunction } from "./codegen/subscribable_sql.js";
 import { generateManifest } from "./codegen/manifest.js";
 import { generateSubscribableStore } from "./codegen/subscribable_store.js";
 import { generateClientSDK } from "./codegen/client.js";
@@ -80,10 +80,13 @@ async function main() {
 
       // Generate subscribable SQL functions
       const subscribableSQL: string[] = [];
+      const subscribableNames = Object.keys(ir.subscribables);
       for (const [name, subIR] of Object.entries(ir.subscribables)) {
         console.log(`[Compiler] Generating SQL for subscribable: ${name}`);
         subscribableSQL.push(generateSubscribableSQL(name, subIR as any, ir.entities));
       }
+      // Generate central compute_affected_keys function that aggregates all subscribables
+      subscribableSQL.push(generateComputeAffectedKeysFunction(subscribableNames));
 
       // Collect custom functions SQL
       const customFunctionSQL: string[] = [];