dzql 0.5.8 → 0.5.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dzql",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "description": "PostgreSQL-powered framework with zero boilerplate CRUD operations and real-time WebSocket synchronization",
   "type": "module",
   "main": "src/server/index.js",

package/src/compiler/codegen/subscribable-codegen.js

@@ -238,13 +238,22 @@ $$ LANGUAGE plpgsql STABLE SECURITY DEFINER;`;
     // Build relation subqueries
     const relationSelects = this._generateRelationSelects();
 
+    // Build schema with path mapping and scope tables (baked in at compile time)
+    const pathMapping = this.buildPathMapping();
+    const scopeTables = this.extractScopeTables();
+    const schemaJson = JSON.stringify({
+      root: this.rootEntity,
+      paths: pathMapping,
+      scopeTables: scopeTables
+    });
+
     return `CREATE OR REPLACE FUNCTION get_${this.name}(
   p_params JSONB,
   p_user_id INT
 ) RETURNS JSONB AS $$
 DECLARE
 ${paramDeclarations}
-  v_result JSONB;
+  v_data JSONB;
 BEGIN
   -- Extract parameters
 ${paramExtractions}
@@ -258,11 +267,15 @@ ${paramExtractions}
   SELECT jsonb_build_object(
     '${this.rootEntity}', row_to_json(root.*)${relationSelects}
   )
-  INTO v_result
+  INTO v_data
   FROM ${this.rootEntity} root
   WHERE ${rootFilter};
 
-  RETURN v_result;
+  -- Return data with embedded schema for atomic updates
+  RETURN jsonb_build_object(
+    'data', v_data,
+    'schema', '${schemaJson}'::jsonb
+  );
 END;
 $$ LANGUAGE plpgsql SECURITY DEFINER;`;
   }

package/src/server/subscriptions.js

@@ -221,50 +221,55 @@ export function getAllSubscriptions() {
  * @returns {Promise<{scopeTables: string[], pathMapping: object, rootEntity: string, relations: object}>}
  */
 export async function getSubscribableMetadata(subscribableName, sql) {
-  // Check cache first
+  // Check cache first (compiled mode populates this from embedded schema)
   if (subscribableMetadataCache.has(subscribableName)) {
     return subscribableMetadataCache.get(subscribableName);
   }
 
-  // Fetch from database
-  const result = await sql`
-    SELECT scope_tables, root_entity, relations
-    FROM dzql.subscribables
-    WHERE name = ${subscribableName}
-  `;
-
-  if (!result || result.length === 0) {
-    // Return empty metadata if subscribable not found
-    const emptyMetadata = {
-      scopeTables: [],
-      pathMapping: {},
-      rootEntity: null,
-      relations: {}
-    };
-    return emptyMetadata;
-  }
+  // Interpreted mode: fetch from database table
+  try {
+    const result = await sql`
+      SELECT scope_tables, root_entity, relations
+      FROM dzql.subscribables
+      WHERE name = ${subscribableName}
+    `;
 
-  const { scope_tables, root_entity, relations } = result[0];
+    if (result && result.length > 0) {
+      const { scope_tables, root_entity, relations } = result[0];
 
-  // Build path mapping from relations
-  const pathMapping = buildPathMappingFromRelations(root_entity, relations);
+      // Build path mapping from relations
+      const pathMapping = buildPathMappingFromRelations(root_entity, relations);
 
-  const metadata = {
-    scopeTables: scope_tables || [],
-    pathMapping,
-    rootEntity: root_entity,
-    relations: relations || {}
-  };
+      const metadata = {
+        scopeTables: scope_tables || [],
+        pathMapping,
+        rootEntity: root_entity,
+        relations: relations || {}
+      };
 
-  // Cache for future use
-  subscribableMetadataCache.set(subscribableName, metadata);
+      // Cache for future use
+      subscribableMetadataCache.set(subscribableName, metadata);
 
-  wsLogger.debug(`Cached metadata for subscribable ${subscribableName}:`, {
-    scopeTables: metadata.scopeTables,
-    pathMapping: metadata.pathMapping
-  });
+      wsLogger.debug(`Cached metadata for subscribable ${subscribableName}:`, {
+        scopeTables: metadata.scopeTables,
+        pathMapping: metadata.pathMapping
+      });
 
-  return metadata;
+      return metadata;
+    }
+  } catch (e) {
+    // Table doesn't exist or query failed
+    wsLogger.debug(`Failed to fetch metadata for ${subscribableName}: ${e.message}`);
+  }
+
+  // Return empty metadata if nothing found (compiled mode without prior subscribe)
+  const emptyMetadata = {
+    scopeTables: [],
+    pathMapping: {},
+    rootEntity: null,
+    relations: {}
+  };
+  return emptyMetadata;
 }
 
 /**
@@ -322,6 +327,18 @@ export function clearSubscribableMetadataCache(subscribableName = null) {
   }
 }
 
+/**
+ * Cache subscribable metadata (used by compiled mode to store embedded schema)
+ * @param {string} subscribableName - Name of the subscribable
+ * @param {object} metadata - Metadata to cache
+ */
+export function cacheSubscribableMetadata(subscribableName, metadata) {
+  subscribableMetadataCache.set(subscribableName, metadata);
+  wsLogger.debug(`Cached compiled metadata for ${subscribableName}:`, {
+    scopeTables: metadata.scopeTables
+  });
+}
+
 /**
  * Get scope tables for a subscribable (convenience function)
  * @param {string} subscribableName - Name of the subscribable

package/src/server/ws.js

@@ -12,7 +12,8 @@ import {
   unregisterSubscription,
   unregisterSubscriptionByParams,
   removeConnectionSubscriptions,
-  getSubscribableMetadata
+  getSubscribableMetadata,
+  cacheSubscribableMetadata
 } from "./subscriptions.js";
 
 // Environment configuration
@@ -322,14 +323,37 @@ export function createRPCHandler(customHandlers = {}) {
         try {
           // Execute initial query (this also checks permissions)
           const queryResult = await sql.unsafe(
-            `SELECT get_${subscribableName}($1, $2) as data`,
+            `SELECT get_${subscribableName}($1, $2) as result`,
             [params, ws.data.user_id]
           );
 
-          const data = queryResult[0]?.data;
-
-          // Get subscribable metadata for schema (path mapping for atomic updates)
-          const metadata = await getSubscribableMetadata(subscribableName, sql);
+          const queryData = queryResult[0]?.result;
+
+          // Check if compiled function returned embedded schema
+          // Compiled: { data, schema } | Interpreted: just the data object
+          let data, schema;
+          if (queryData && queryData.schema && queryData.data !== undefined) {
+            // Compiled mode - schema is embedded (includes scopeTables)
+            data = queryData.data;
+            schema = queryData.schema;
+            // Cache scopeTables for event filtering
+            if (schema.scopeTables) {
+              cacheSubscribableMetadata(subscribableName, {
+                scopeTables: schema.scopeTables,
+                pathMapping: schema.paths,
+                rootEntity: schema.root,
+                relations: {}
+              });
+            }
+          } else {
+            // Interpreted mode - fetch schema from metadata table
+            data = queryData;
+            const metadata = await getSubscribableMetadata(subscribableName, sql);
+            schema = {
+              root: metadata.rootEntity,
+              paths: metadata.pathMapping
+            };
+          }
 
           // Register subscription in memory
           const subscriptionId = registerSubscription(
@@ -343,11 +367,7 @@ export function createRPCHandler(customHandlers = {}) {
           const result = {
             subscription_id: subscriptionId,
             data,
-            // Include schema for atomic update support
-            schema: {
-              root: metadata.rootEntity,
-              paths: metadata.pathMapping
-            }
+            schema
           };
 
           wsLogger.response(method, result, Date.now() - startTime);