dzql 0.1.5 → 0.2.0

package/src/client/stores/useWsStore.js

@@ -0,0 +1,289 @@
+/**
+ * Canonical DZQL WebSocket Pinia Store
+ *
+ * Manages WebSocket connection with three-phase lifecycle:
+ * 1. CONNECTING - Initial connection to server
+ * 2. AUTHENTICATING - After connection, waiting for profile (login if needed)
+ * 3. READY - Connected and authenticated, ready for use
+ *
+ * @example
+ * // In your app
+ * import { useWsStore } from 'dzql/client/stores'
+ *
+ * const wsStore = useWsStore()
+ * await wsStore.connect() // or connect with custom URL
+ *
+ * // Access profile
+ * console.log(wsStore.profile) // null if not authenticated
+ *
+ * // Login
+ * await wsStore.login({ email: 'user@example.com', password: 'pass' })
+ *
+ * // Logout
+ * await wsStore.logout()
+ */
+import { defineStore } from 'pinia'
+import { ref, computed } from 'vue'
+import { WebSocketManager } from '../ws.js'
+
+export const useWsStore = defineStore('dzql-ws', () => {
+  // ===== State =====
+
+  /**
+   * Connection state: 'disconnected' | 'connecting' | 'connected' | 'error'
+   */
+  const connectionState = ref('disconnected')
+
+  /**
+   * App state: 'connecting' | 'login' | 'ready'
+   * - connecting: Initial connection phase
+   * - login: Connected but needs authentication
+   * - ready: Connected and authenticated
+   */
+  const appState = ref('connecting')
+
+  /**
+   * User profile (null if not authenticated)
+   */
+  const profile = ref(null)
+
+  /**
+   * Last error message
+   */
+  const error = ref(null)
+
+  /**
+   * WebSocket manager instance
+   */
+  const ws = new WebSocketManager()
+
+  // ===== Computed =====
+
+  const isConnected = computed(() => connectionState.value === 'connected')
+  const isAuthenticated = computed(() => profile.value !== null)
+  const isReady = computed(() => appState.value === 'ready')
+  const needsLogin = computed(() => appState.value === 'login')
+  const isConnecting = computed(() => appState.value === 'connecting')
+
+  // ===== Actions =====
+
+  /**
+   * Connect to WebSocket server
+   *
+   * @param {string|null} url - WebSocket URL (auto-detected if null)
+   * @param {number} timeout - Connection timeout in ms
+   * @returns {Promise<void>}
+   *
+   * @example
+   * // Auto-detect URL
+   * await wsStore.connect()
+   *
+   * @example
+   * // Custom URL for development
+   * await wsStore.connect('ws://localhost:3000/ws')
+   */
+  async function connect(url = null, timeout = 5000) {
+    try {
+      appState.value = 'connecting'
+      connectionState.value = 'connecting'
+      error.value = null
+
+      // Set up broadcast listener for connection events BEFORE connecting
+      ws.onBroadcast((method, params) => {
+        if (method === 'connected') {
+          connectionState.value = 'connected'
+          profile.value = params.profile || null
+
+          // Determine app state based on profile
+          if (params.profile) {
+            appState.value = 'ready'
+          } else {
+            appState.value = 'login'
+          }
+
+          console.log('[WsStore] Connected:', {
+            profile: params.profile,
+            appState: appState.value
+          })
+        }
+      })
+
+      // Connect to WebSocket
+      await ws.connect(url, timeout)
+
+      // Note: appState will be updated when 'connected' broadcast arrives
+
+    } catch (err) {
+      console.error('[WsStore] Connection failed:', err)
+      connectionState.value = 'error'
+      error.value = err.message
+      throw err
+    }
+  }
+
+  /**
+   * Login with email and password
+   *
+   * @param {Object} credentials
+   * @param {string} credentials.email
+   * @param {string} credentials.password
+   * @returns {Promise<Object>} Login result with token and profile
+   *
+   * @example
+   * const result = await wsStore.login({
+   *   email: 'user@example.com',
+   *   password: 'password123'
+   * })
+   */
+  async function login({ email, password }) {
+    try {
+      error.value = null
+
+      const result = await ws.call('login_user', { email, password })
+
+      if (result.token) {
+        // Store token in localStorage
+        if (typeof localStorage !== 'undefined') {
+          localStorage.setItem('dzql_token', result.token)
+        }
+
+        // Update profile
+        profile.value = result.profile
+        appState.value = 'ready'
+
+        console.log('[WsStore] Login successful:', result.profile)
+
+        return result
+      }
+
+      throw new Error('No token received')
+
+    } catch (err) {
+      console.error('[WsStore] Login failed:', err)
+      error.value = err.message
+      throw err
+    }
+  }
+
+  /**
+   * Register a new user
+   *
+   * @param {Object} credentials
+   * @param {string} credentials.email
+   * @param {string} credentials.password
+   * @returns {Promise<Object>} Registration result with token and profile
+   *
+   * @example
+   * const result = await wsStore.register({
+   *   email: 'newuser@example.com',
+   *   password: 'securepass123'
+   * })
+   */
+  async function register({ email, password }) {
+    try {
+      error.value = null
+
+      const result = await ws.call('register_user', { email, password })
+
+      if (result.token) {
+        // Store token in localStorage
+        if (typeof localStorage !== 'undefined') {
+          localStorage.setItem('dzql_token', result.token)
+        }
+
+        // Update profile
+        profile.value = result.profile
+        appState.value = 'ready'
+
+        console.log('[WsStore] Registration successful:', result.profile)
+
+        return result
+      }
+
+      throw new Error('No token received')
+
+    } catch (err) {
+      console.error('[WsStore] Registration failed:', err)
+      error.value = err.message
+      throw err
+    }
+  }
+
+  /**
+   * Logout and clear session
+   *
+   * @returns {Promise<void>}
+   *
+   * @example
+   * await wsStore.logout()
+   */
+  async function logout() {
+    try {
+      // Call server logout
+      await ws.call('logout')
+    } catch (err) {
+      console.warn('[WsStore] Server logout failed:', err)
+    }
+
+    // Clear local state
+    if (typeof localStorage !== 'undefined') {
+      localStorage.removeItem('dzql_token')
+    }
+
+    profile.value = null
+    appState.value = 'login'
+
+    // Reconnect to get fresh state
+    await connect()
+
+    console.log('[WsStore] Logged out')
+  }
+
+  /**
+   * Disconnect from WebSocket
+   */
+  function disconnect() {
+    ws.disconnect()
+    connectionState.value = 'disconnected'
+    appState.value = 'connecting'
+    console.log('[WsStore] Disconnected')
+  }
+
+  /**
+   * Get the WebSocket manager instance for direct API calls
+   *
+   * @returns {WebSocketManager}
+   *
+   * @example
+   * const ws = wsStore.getWs()
+   * const venue = await ws.api.get.venues({ id: 1 })
+   */
+  function getWs() {
+    return ws
+  }
+
+  // ===== Return Public API =====
+
+  return {
+    // State
+    connectionState,
+    appState,
+    profile,
+    error,
+
+    // Computed
+    isConnected,
+    isAuthenticated,
+    isReady,
+    needsLogin,
+    isConnecting,
+
+    // Actions
+    connect,
+    login,
+    register,
+    logout,
+    disconnect,
+    getWs
+  }
+})

package/src/client/ws.js

@@ -59,12 +59,11 @@ class WebSocketManager {
     this.pendingRequests = new Map();
     this.broadcastCallbacks = new Set();
     this.sidRequestHandlers = new Set();
+    this.subscriptions = new Map(); // subscription_id -> { callback, unsubscribe }
     this.reconnectAttempts = 0;
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 5;
     this.isShuttingDown = false;
 
-    // Ad
-
     // DZQL nested proxy API - matches server-side db.api pattern
     // Proxy handles both DZQL operations and custom functions
     const dzqlOps = {
@@ -137,6 +136,18 @@ class WebSocketManager {
         if (prop in target) {
           return target[prop];
         }
+        // Handle subscribe_* methods specially
+        if (prop.startsWith('subscribe_')) {
+          return (params = {}, callback) => {
+            return this.subscribe(prop, params, callback);
+          };
+        }
+        // Handle unsubscribe_* methods
+        if (prop.startsWith('unsubscribe_')) {
+          return (params = {}) => {
+            return this.unsubscribe(prop, params);
+          };
+        }
         // All other properties are treated as custom function calls
         return (params = {}) => {
           return this.call(prop, params);
@@ -314,6 +325,16 @@ class WebSocketManager {
         resolve(message.result);
       }
     } else {
+      // Handle subscription updates
+      if (message.method === "subscription:update") {
+        const { subscription_id, data } = message.params;
+        const sub = this.subscriptions.get(subscription_id);
+        if (sub && sub.callback) {
+          sub.callback(data);
+        }
+        return;
+      }
+
       // Handle broadcasts and SID requests
 
       // Check if this is a SID request from server
@@ -376,6 +397,70 @@ class WebSocketManager {
     });
   }
 
+  /**
+   * Subscribe to a live query
+   *
+   * @param {string} method - Method name (subscribe_<subscribable>)
+   * @param {object} params - Subscription parameters
+   * @param {function} callback - Callback function for updates
+   * @returns {Promise<{data, subscription_id, unsubscribe}>} Initial data and unsubscribe function
+   *
+   * @example
+   * const { data, unsubscribe } = await ws.api.subscribe_venue_detail(
+   *   { venue_id: 1 },
+   *   (updated) => console.log('Updated:', updated)
+   * );
+   *
+   * // Use initial data
+   * console.log('Initial:', data);
+   *
+   * // Later: unsubscribe
+   * unsubscribe();
+   */
+  async subscribe(method, params = {}, callback) {
+    if (!callback || typeof callback !== 'function') {
+      throw new Error('Subscribe requires a callback function');
+    }
+
+    // Call server to register subscription
+    const result = await this.call(method, params);
+    const { subscription_id, data } = result;
+
+    // Create unsubscribe function
+    const unsubscribeFn = async () => {
+      const unsubMethod = method.replace('subscribe_', 'unsubscribe_');
+      await this.call(unsubMethod, params);
+      this.subscriptions.delete(subscription_id);
+    };
+
+    // Store callback for updates
+    this.subscriptions.set(subscription_id, {
+      callback,
+      unsubscribe: unsubscribeFn
+    });
+
+    // Return initial data and unsubscribe function
+    return {
+      data,
+      subscription_id,
+      unsubscribe: unsubscribeFn
+    };
+  }
+
+  /**
+   * Unsubscribe from a live query
+   *
+   * @param {string} method - Method name (unsubscribe_<subscribable>)
+   * @param {object} params - Subscription parameters
+   * @returns {Promise<{success: boolean}>}
+   *
+   * @example
+   * await ws.api.unsubscribe_venue_detail({ venue_id: 1 });
+   */
+  async unsubscribe(method, params = {}) {
+    return await this.call(method, params);
+  }
+
   /**
    * Register callback for real-time broadcast events
    *

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

@@ -385,6 +385,31 @@ $$ LANGUAGE plpgsql SECURITY DEFINER;`;
     AND (${validTo} > COALESCE(p_on_date, NOW()) OR ${validTo} IS NULL)`;
   }
 
+  /**
+   * Check if a trigger has any rules with actions
+   * @private
+   */
+  _hasGraphRuleActions(trigger) {
+    const rules = this.entity.graphRules[trigger];
+    if (!rules || typeof rules !== 'object') {
+      return false;
+    }
+
+    // Check if any rule has actions
+    for (const ruleConfig of Object.values(rules)) {
+      if (ruleConfig && ruleConfig.actions) {
+        const actions = Array.isArray(ruleConfig.actions)
+          ? ruleConfig.actions
+          : [ruleConfig.actions];
+        if (actions.length > 0) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Generate graph rules call
    * @private
@@ -396,7 +421,7 @@ $$ LANGUAGE plpgsql SECURITY DEFINER;`;
 
     // For DELETE operation
     if (operation === 'delete') {
-      if (this.entity.graphRules.on_delete) {
+      if (this._hasGraphRuleActions('on_delete')) {
         return `
   -- Execute graph rules: on_delete
   PERFORM _graph_${this.tableName}_on_delete(p_user_id, to_jsonb(v_result));`;
@@ -407,7 +432,7 @@ $$ LANGUAGE plpgsql SECURITY DEFINER;`;
     // For SAVE operation (create/update)
     const calls = [];
 
-    if (this.entity.graphRules.on_create) {
+    if (this._hasGraphRuleActions('on_create')) {
       calls.push(`
   -- Execute graph rules: on_create (if insert)
   IF v_is_insert THEN
@@ -415,7 +440,7 @@ $$ LANGUAGE plpgsql SECURITY DEFINER;`;
   END IF;`);
     }
 
-    if (this.entity.graphRules.on_update) {
+    if (this._hasGraphRuleActions('on_update')) {
       calls.push(`
   -- Execute graph rules: on_update (if update)
   IF NOT v_is_insert THEN