dzql 0.6.14 → 0.6.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.6.14",
+  "version": "0.6.16",
   "description": "Database-first real-time framework with TypeScript support",
   "repository": {
     "type": "git",

package/src/cli/codegen/sql.ts

@@ -1,6 +1,6 @@
 import { compilePermission } from "../compiler/permissions.js";
 import { compileGraphRules } from "../compiler/graph_rules.js";
-import type { EntityIR, ManyToManyIR } from "../../shared/ir.js";
+import type { EntityIR, ManyToManyIR, IncludeIR } from "../../shared/ir.js";
 
 /** Column info from EntityIR */
 interface ColumnInfo {
@@ -313,6 +313,32 @@ export function generateSaveFunction(name: string, entityIR: EntityIR): string {
     return sql;
   }).join('\n');
 
+  // FK expansion (add related objects to output for real-time events)
+  // Only expand direct FKs (where key_id column exists), not reverse FKs (child arrays)
+  const includes: Record<string, IncludeIR> = entityIR.includes || {};
+  const includeKeys = Object.keys(includes);
+  const fkExpansion = includeKeys.map(key => {
+    const config: IncludeIR = includes[key];
+    const targetEntity = config.entity;
+    const fkField = `${key}_id`; // Convention: author -> author_id
+
+    // Only expand if this is a direct FK (key_id column exists)
+    const hasFkColumn = entityIR.columns.some((c: ColumnInfo) => c.name === fkField);
+
+    if (hasFkColumn) {
+      // Direct FK: single object expansion (e.g., author_id -> author object)
+      return `
+  -- FK: Add ${key} to output (from ${fkField})
+  IF (v_result->>'${fkField}') IS NOT NULL THEN
+    v_result := v_result || jsonb_build_object('${key}',
+      (SELECT to_jsonb(t.*) FROM ${targetEntity} t WHERE t.id = (v_result->>'${fkField}')::int));
+  END IF;`;
+    }
+    // Skip reverse FKs - they would require querying child tables which may not exist
+    // and are not needed for the primary use case of expanding the saved record
+    return '';
+  }).filter(s => s).join('\n');
+
   return `
 CREATE OR REPLACE FUNCTION dzql_v2.save_${name}(p_user_id int, p_data jsonb)
 RETURNS jsonb
@@ -365,6 +391,7 @@ ${m2mExtraction}
   END IF;
 ${m2mSync}
 ${m2mExpansion}
+${fkExpansion}
 
   -- Resolve notification recipients
   v_notify_users := dzql_v2.${name}_notify_users(p_user_id, v_result);

package/src/cli/codegen/subscribable_sql.ts

@@ -512,10 +512,18 @@ 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);
@@ -552,18 +560,30 @@ function generateAffectedKeysFunction(name: string, sub: SubscribableIR): string
       const parentRel = relationships[parentEntity]?.[relEntity];
       const fkField = parentRel?.fkOnParent || `${relName}_id`;
 
-      cases.push(`    WHEN '${relEntity}' THEN
+      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.${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 {
       // Direct child of root - use the FK on child that points to root
       const keyField = fkOnChild || `${singularRootEntity}_id`;
-      cases.push(`    WHEN '${relEntity}' THEN
+      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

package/src/cli/compiler/ir.ts

@@ -175,6 +175,9 @@ export function generateIR(domain: DomainConfig): DomainIR {
       };
     }
 
+    // Parse includes (FK expansions)
+    const includes = parseIncludes(config.includes as Record<string, string | IncludeConfig> | undefined);
+
     entities[name] = {
       name,
       table: name,
@@ -187,6 +190,7 @@ export function generateIR(domain: DomainConfig): DomainIR {
       fieldDefaults: config.fieldDefaults || {},
       permissions,
       relationships: {},
+      includes,
       manyToMany,
       graphRules: {
         onCreate: onCreateRules,

package/src/runtime/index.ts

@@ -93,7 +93,11 @@ function processEventNotifications(event: {
     for (const [subscribableName, subs] of subscriptionsByName.entries()) {
       for (const sub of subs) {
         const paramValues = Object.values(sub.params);
-        const subKey = `${subscribableName}:${paramValues.join(':')}`;
+        // For subscribables with no params, the key is just the name
+        // For subscribables with params, the key is name:param1:param2:...
+        const subKey = paramValues.length > 0
+          ? `${subscribableName}:${paramValues.join(':')}`
+          : subscribableName;
 
         if (affected_keys.includes(subKey)) {
           // Send entity broadcast (not subscription:event) so global dispatcher can route it

package/src/shared/ir.ts

@@ -130,6 +130,7 @@ export interface EntityIR {
     delete: string[];
   };
   relationships: Record<string, RelationshipIR>;
+  includes: Record<string, IncludeIR>; // FK expansions (e.g., author: users)
   manyToMany: Record<string, ManyToManyIR>;
   graphRules: {
     onCreate: GraphRuleIR[];