remdb 0.3.180__py3-none-any.whl → 0.3.258__py3-none-any.whl

rem/sql/migrations/004_cache_system.sql

@@ -1,16 +1,15 @@
 -- REM Cache System
--- Description: Self-healing cache for UNLOGGED tables (kv_store)
+-- Description: Cache management helpers for UNLOGGED tables (kv_store)
 -- Version: 1.0.0
 -- Date: 2025-11-29
 --
 -- This migration adds:
 --   1. cache_system_state table for debouncing and API secret storage
 --   2. maybe_trigger_kv_rebuild() function for async rebuild triggering
---   3. Updated rem_lookup/fuzzy/traverse with self-healing on empty cache
+--   3. Helper functions for cache management
 --
--- Self-Healing Flow:
---   Query returns 0 results → Check if kv_store empty → Trigger async rebuild
---   Priority: pg_net (if available) → dblink (always available)
+-- NOTE: Core functions (rem_lookup, rem_fuzzy, rem_traverse) are defined in 001_install.sql
+-- This file only provides cache-specific infrastructure.
 
 -- ============================================================================
 -- REQUIRED EXTENSION
@@ -65,9 +64,11 @@ CREATE OR REPLACE FUNCTION rem_kv_store_empty(p_user_id TEXT)
 RETURNS BOOLEAN AS $$
 BEGIN
     -- Quick existence check - very fast with index
+    -- Check for user-specific OR public (NULL user_id) entries
+    -- This ensures self-healing triggers correctly for public ontologies
     RETURN NOT EXISTS (
         SELECT 1 FROM kv_store
-        WHERE user_id = p_user_id
+        WHERE user_id = p_user_id OR user_id IS NULL
         LIMIT 1
     );
 END;
@@ -194,271 +195,6 @@ $$ LANGUAGE plpgsql;
 COMMENT ON FUNCTION maybe_trigger_kv_rebuild IS
 'Async trigger for kv_store rebuild. Uses pg_net (API) or dblink (SQL). Includes debouncing.';
 
--- ============================================================================
--- UPDATED: rem_lookup with self-healing
--- ============================================================================
-
-CREATE OR REPLACE FUNCTION rem_lookup(
-    p_entity_key VARCHAR(255),
-    p_tenant_id VARCHAR(100),
-    p_user_id VARCHAR(100)
-)
-RETURNS TABLE(
-    entity_type VARCHAR(100),
-    data JSONB
-) AS $$
-DECLARE
-    entity_table VARCHAR(100);
-    query_sql TEXT;
-    effective_user_id VARCHAR(100);
-    v_result_count INTEGER := 0;
-BEGIN
-    effective_user_id := COALESCE(p_user_id, p_tenant_id);
-
-    -- First lookup in KV store to get entity_type (table name)
-    SELECT kv.entity_type INTO entity_table
-    FROM kv_store kv
-    WHERE (kv.user_id = effective_user_id OR kv.user_id IS NULL)
-    AND kv.entity_key = p_entity_key
-    LIMIT 1;
-
-    -- If not found, check if cache is empty and maybe trigger rebuild
-    IF entity_table IS NULL THEN
-        -- SELF-HEALING: Check if this is because cache is empty
-        IF rem_kv_store_empty(effective_user_id) THEN
-            PERFORM maybe_trigger_kv_rebuild(effective_user_id, 'rem_lookup');
-        END IF;
-        RETURN;
-    END IF;
-
-    -- Fetch raw record from underlying table as JSONB
-    query_sql := format('
-        SELECT
-            %L::VARCHAR(100) AS entity_type,
-            row_to_json(t)::jsonb AS data
-        FROM %I t
-        WHERE (t.user_id = $1 OR t.user_id IS NULL)
-        AND t.name = $2
-        AND t.deleted_at IS NULL
-    ', entity_table, entity_table);
-
-    RETURN QUERY EXECUTE query_sql USING effective_user_id, p_entity_key;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
--- ============================================================================
--- UPDATED: rem_fuzzy with self-healing
--- ============================================================================
-
-CREATE OR REPLACE FUNCTION rem_fuzzy(
-    p_query TEXT,
-    p_tenant_id VARCHAR(100),
-    p_threshold REAL DEFAULT 0.3,
-    p_limit INTEGER DEFAULT 10,
-    p_user_id VARCHAR(100) DEFAULT NULL
-)
-RETURNS TABLE(
-    entity_type VARCHAR(100),
-    similarity_score REAL,
-    data JSONB
-) AS $$
-DECLARE
-    kv_matches RECORD;
-    entities_by_table JSONB := '{}'::jsonb;
-    table_keys JSONB;
-    effective_user_id VARCHAR(100);
-    v_found_any BOOLEAN := FALSE;
-BEGIN
-    effective_user_id := COALESCE(p_user_id, p_tenant_id);
-
-    -- Find matching keys in KV store
-    FOR kv_matches IN
-        SELECT
-            kv.entity_key,
-            kv.entity_type,
-            similarity(kv.entity_key, p_query) AS sim_score
-        FROM kv_store kv
-        WHERE (kv.user_id = effective_user_id OR kv.user_id IS NULL)
-        AND kv.entity_key % p_query
-        AND similarity(kv.entity_key, p_query) >= p_threshold
-        ORDER BY sim_score DESC
-        LIMIT p_limit
-    LOOP
-        v_found_any := TRUE;
-        -- Build JSONB mapping {table: [keys]}
-        IF entities_by_table ? kv_matches.entity_type THEN
-            table_keys := entities_by_table->kv_matches.entity_type;
-            entities_by_table := jsonb_set(
-                entities_by_table,
-                ARRAY[kv_matches.entity_type],
-                table_keys || jsonb_build_array(kv_matches.entity_key)
-            );
-        ELSE
-            entities_by_table := jsonb_set(
-                entities_by_table,
-                ARRAY[kv_matches.entity_type],
-                jsonb_build_array(kv_matches.entity_key)
-            );
-        END IF;
-    END LOOP;
-
-    -- SELF-HEALING: If no matches and cache is empty, trigger rebuild
-    IF NOT v_found_any AND rem_kv_store_empty(effective_user_id) THEN
-        PERFORM maybe_trigger_kv_rebuild(effective_user_id, 'rem_fuzzy');
-    END IF;
-
-    -- Fetch full records
-    RETURN QUERY
-    SELECT
-        f.entity_type::VARCHAR(100),
-        similarity(f.entity_key, p_query) AS similarity_score,
-        f.entity_record AS data
-    FROM rem_fetch(entities_by_table, effective_user_id) f
-    ORDER BY similarity_score DESC;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
--- ============================================================================
--- UPDATED: rem_traverse with self-healing
--- ============================================================================
-
-CREATE OR REPLACE FUNCTION rem_traverse(
-    p_entity_key VARCHAR(255),
-    p_tenant_id VARCHAR(100),
-    p_user_id VARCHAR(100),
-    p_max_depth INTEGER DEFAULT 1,
-    p_rel_type VARCHAR(100) DEFAULT NULL,
-    p_keys_only BOOLEAN DEFAULT FALSE
-)
-RETURNS TABLE(
-    depth INTEGER,
-    entity_key VARCHAR(255),
-    entity_type VARCHAR(100),
-    entity_id UUID,
-    rel_type VARCHAR(100),
-    rel_weight REAL,
-    path TEXT[],
-    entity_record JSONB
-) AS $$
-DECLARE
-    graph_keys RECORD;
-    entities_by_table JSONB := '{}'::jsonb;
-    table_keys JSONB;
-    effective_user_id VARCHAR(100);
-    v_found_start BOOLEAN := FALSE;
-BEGIN
-    effective_user_id := COALESCE(p_user_id, p_tenant_id);
-
-    -- Check if start entity exists in kv_store
-    SELECT TRUE INTO v_found_start
-    FROM kv_store kv
-    WHERE (kv.user_id = effective_user_id OR kv.user_id IS NULL)
-    AND kv.entity_key = p_entity_key
-    LIMIT 1;
-
-    -- SELF-HEALING: If start not found and cache is empty, trigger rebuild
-    IF NOT COALESCE(v_found_start, FALSE) THEN
-        IF rem_kv_store_empty(effective_user_id) THEN
-            PERFORM maybe_trigger_kv_rebuild(effective_user_id, 'rem_traverse');
-        END IF;
-        RETURN;
-    END IF;
-
-    -- Original traverse logic
-    FOR graph_keys IN
-        WITH RECURSIVE graph_traversal AS (
-            SELECT
-                0 AS depth,
-                kv.entity_key,
-                kv.entity_type,
-                kv.entity_id,
-                NULL::VARCHAR(100) AS rel_type,
-                NULL::REAL AS rel_weight,
-                ARRAY[kv.entity_key]::TEXT[] AS path
-            FROM kv_store kv
-            WHERE (kv.user_id = effective_user_id OR kv.user_id IS NULL)
-            AND kv.entity_key = p_entity_key
-
-            UNION ALL
-
-            SELECT
-                gt.depth + 1,
-                target_kv.entity_key,
-                target_kv.entity_type,
-                target_kv.entity_id,
-                (edge->>'rel_type')::VARCHAR(100) AS rel_type,
-                COALESCE((edge->>'weight')::REAL, 1.0) AS rel_weight,
-                gt.path || target_kv.entity_key AS path
-            FROM graph_traversal gt
-            JOIN kv_store source_kv ON source_kv.entity_key = gt.entity_key
-                AND (source_kv.user_id = effective_user_id OR source_kv.user_id IS NULL)
-            CROSS JOIN LATERAL jsonb_array_elements(COALESCE(source_kv.graph_edges, '[]'::jsonb)) AS edge
-            JOIN kv_store target_kv ON target_kv.entity_key = (edge->>'dst')::VARCHAR(255)
-                AND (target_kv.user_id = effective_user_id OR target_kv.user_id IS NULL)
-            WHERE gt.depth < p_max_depth
-            AND (p_rel_type IS NULL OR (edge->>'rel_type')::VARCHAR(100) = p_rel_type)
-            AND NOT (target_kv.entity_key = ANY(gt.path))
-        )
-        SELECT DISTINCT ON (gt.entity_key)
-            gt.depth,
-            gt.entity_key,
-            gt.entity_type,
-            gt.entity_id,
-            gt.rel_type,
-            gt.rel_weight,
-            gt.path
-        FROM graph_traversal gt
-        WHERE gt.depth > 0
-        ORDER BY gt.entity_key, gt.depth
-    LOOP
-        IF p_keys_only THEN
-            depth := graph_keys.depth;
-            entity_key := graph_keys.entity_key;
-            entity_type := graph_keys.entity_type;
-            entity_id := graph_keys.entity_id;
-            rel_type := graph_keys.rel_type;
-            rel_weight := graph_keys.rel_weight;
-            path := graph_keys.path;
-            entity_record := NULL;
-            RETURN NEXT;
-        ELSE
-            IF entities_by_table ? graph_keys.entity_type THEN
-                table_keys := entities_by_table->graph_keys.entity_type;
-                entities_by_table := jsonb_set(
-                    entities_by_table,
-                    ARRAY[graph_keys.entity_type],
-                    table_keys || jsonb_build_array(graph_keys.entity_key)
-                );
-            ELSE
-                entities_by_table := jsonb_set(
-                    entities_by_table,
-                    ARRAY[graph_keys.entity_type],
-                    jsonb_build_array(graph_keys.entity_key)
-                );
-            END IF;
-        END IF;
-    END LOOP;
-
-    IF NOT p_keys_only THEN
-        RETURN QUERY
-        SELECT
-            g.depth,
-            g.entity_key,
-            g.entity_type,
-            g.entity_id,
-            g.rel_type,
-            g.rel_weight,
-            g.path,
-            f.entity_record
-        FROM (
-            SELECT * FROM rem_traverse(p_entity_key, p_tenant_id, effective_user_id, p_max_depth, p_rel_type, TRUE)
-        ) g
-        LEFT JOIN rem_fetch(entities_by_table, effective_user_id) f
-            ON g.entity_key = f.entity_key;
-    END IF;
-END;
-$$ LANGUAGE plpgsql STABLE;
-
 -- ============================================================================
 -- HELPER: Get API secret for validation
 -- ============================================================================
@@ -527,9 +263,9 @@ BEGIN
     RAISE NOTICE '';
     RAISE NOTICE 'Functions:';
     RAISE NOTICE '  maybe_trigger_kv_rebuild() - Async rebuild trigger';
-    RAISE NOTICE '  rem_lookup() - Updated with self-healing';
-    RAISE NOTICE '  rem_fuzzy() - Updated with self-healing';
-    RAISE NOTICE '  rem_traverse() - Updated with self-healing';
+    RAISE NOTICE '  rem_kv_store_empty() - Check if cache is empty';
+    RAISE NOTICE '  rem_get_cache_api_secret() - Get API secret';
+    RAISE NOTICE '  rem_record_cache_rebuild() - Record rebuild completion';
     RAISE NOTICE '';
     RAISE NOTICE 'Async Methods Available:';
     IF v_has_pgnet THEN
@@ -542,7 +278,5 @@ BEGIN
     ELSE
         RAISE NOTICE '  [ ] dblink - Not installed';
     END IF;
-    RAISE NOTICE '';
-    RAISE NOTICE 'Self-Healing: Queries will auto-trigger rebuild on empty cache';
     RAISE NOTICE '============================================================';
 END $$;

rem/sql/migrations/migrate_session_id_to_uuid.sql

@@ -0,0 +1,45 @@
+-- Migration: Update messages.session_id from session name to session UUID
+-- This fixes the bug where messages were stored with session.name instead of session.id
+--
+-- Run this migration AFTER deploying the code fixes in remdb 0.3.204+
+-- The code now correctly stores session.id (UUID), but existing data needs migration.
+
+BEGIN;
+
+-- First, count how many messages need to be updated
+DO $$
+DECLARE
+    count_to_migrate INTEGER;
+BEGIN
+    SELECT COUNT(*) INTO count_to_migrate
+    FROM messages m
+    JOIN sessions s ON m.session_id = s.name
+    WHERE m.session_id != s.id::text;
+
+    RAISE NOTICE 'Messages needing migration: %', count_to_migrate;
+END $$;
+
+-- Update messages.session_id from session name to session UUID
+UPDATE messages m
+SET session_id = s.id::text
+FROM sessions s
+WHERE m.session_id = s.name
+  AND m.session_id != s.id::text;
+
+-- Report how many were updated
+DO $$
+DECLARE
+    updated_count INTEGER;
+BEGIN
+    GET DIAGNOSTICS updated_count = ROW_COUNT;
+    RAISE NOTICE 'Messages updated: %', updated_count;
+END $$;
+
+COMMIT;
+
+-- Verify the fix - all messages should now join by UUID
+SELECT
+    'Messages matching sessions by UUID' as status,
+    COUNT(*) as count
+FROM messages m
+JOIN sessions s ON m.session_id = s.id::text;