Include all columns
                  SELECT 
                    'INSERT' AS __op__,
                    ${d.map(({column_name:u})=>`curr."${u}" AS "${u}"`).join(`,
`)},
                    ARRAY[]::text[] AS __changed_columns__
                  FROM curr
                  LEFT JOIN prev ON curr.${i} = prev.${i}
                  WHERE prev.${i} IS NULL
                UNION ALL
                  -- DELETE operations: Include only the primary key
                  SELECT 
                    'DELETE' AS __op__,
                    ${d.map(({column_name:u,data_type:D,udt_name:X})=>u===i?`prev."${u}" AS "${u}"`:`NULL${D==="USER-DEFINED"?`::${X}`:""} AS "${u}"`).join(`,
`)},
                      ARRAY[]::text[] AS __changed_columns__
                  FROM prev
                  LEFT JOIN curr ON prev.${i} = curr.${i}
                  WHERE curr.${i} IS NULL
                UNION ALL
                  -- UPDATE operations: Include only changed columns
                  SELECT 
                    'UPDATE' AS __op__,
                    ${d.map(({column_name:u,data_type:D,udt_name:X})=>u===i?`curr."${u}" AS "${u}"`:`CASE 
                              WHEN curr."${u}" IS DISTINCT FROM prev."${u}" 
                              THEN curr."${u}"
                              ELSE NULL${D==="USER-DEFINED"?`::${X}`:""}
                              END AS "${u}"`).join(`,
`)},
                      ARRAY(SELECT unnest FROM unnest(ARRAY[${d.filter(({column_name:u})=>u!==i).map(({column_name:u})=>`CASE
                              WHEN curr."${u}" IS DISTINCT FROM prev."${u}" 
                              THEN '${u}' 
                              ELSE NULL 
                              END`).join(", ")}]) WHERE unnest IS NOT NULL) AS __changed_columns__
                  FROM curr
                  INNER JOIN prev ON curr.${i} = prev.${i}
                  WHERE NOT (curr IS NOT DISTINCT FROM prev)
                )
              SELECT * FROM data_diff;
            `)}})};await S();let O=ne(async()=>{if(p.length===0&&R)return;let y=!1;for(let a=0;a<5;a++)try{await e.transaction(async d=>{await d.exec(`
                INSERT INTO live_query_${o}_state${f} 
                  SELECT * FROM live_query_${o}_view;
              `),R=await d.query(`EXECUTE live_query_${o}_diff${f};`),f=f===1?2:1,await d.exec(`
                TRUNCATE live_query_${o}_state${f};
              `)});break}catch(d){if(d.message===`relation "live_query_${o}_state${f}" does not exist`){y=!0,await S();continue}else throw d}lt(p,[...y?[{__op__:"RESET"}]:[],...R.rows])}),$=await Promise.all(w.map(y=>e.listen(`table_change__${y.schema_name}__${y.table_name}`,async()=>O()))),M=y=>{if(A)throw new Error("Live query is no longer active and cannot be subscribed to");p.push(y)},N=async y=>{y?p=p.filter(a=>a!==a):p=[],p.length===0&&(A=!0,await Promise.all($.map(a=>a())),await e.exec(`
            DROP VIEW IF EXISTS live_query_${o}_view;
            DROP TABLE IF EXISTS live_query_${o}_state1;
            DROP TABLE IF EXISTS live_query_${o}_state2;
            DEALLOCATE live_query_${o}_diff1;
            DEALLOCATE live_query_${o}_diff2;
          `))};return m?.aborted?await N():m?.addEventListener("abort",()=>{N()},{once:!0}),await O(),{fields:R.fields.filter(y=>!["__after__","__op__","__changed_columns__"].includes(y.name)),initialChanges:R.rows,subscribe:M,unsubscribe:N,refresh:O}},async incrementalQuery(r,c,i,h){let m;if(typeof r!="string"&&(m=r.signal,c=r.params,i=r.key,h=r.callback,r=r.query),!i)throw new Error("key is required for incremental queries");let p=h?[h]:[],o=new Map,A=new Map,w=[],f=!0,{fields:R,unsubscribe:S,refresh:O}=await s.changes(r,c,i,N=>{for(let a of N){let{__op__:d,__changed_columns__:I,...b}=a;switch(d){case"RESET":o.clear(),A.clear();break;case"INSERT":o.set(b[i],b),A.set(b.__after__,b[i]);break;case"DELETE":{let u=o.get(b[i]);o.delete(b[i]),u.__after__!==null&&A.delete(u.__after__);break}case"UPDATE":{let u={...o.get(b[i])??{}};for(let D of I)u[D]=b[D],D==="__after__"&&A.set(b.__after__,b[i]);o.set(b[i],u);break}}}let x=[],y=null;for(let a=0;a<o.size;a++){let d=A.get(y),I=o.get(d);if(!I)break;let b={...I};delete b.__after__,x.push(b),y=d}w=x,f||z(p,{rows:x,fields:R})});f=!1,z(p,{rows:w,fields:R});let $=N=>{p.push(N)},M=async N=>{N?p=p.filter(x=>x!==x):p=[],p.length===0&&await S()};return m?.aborted?await M():m?.addEventListener("abort",()=>{M()},{once:!0}),{initialResults:{rows:w,fields:R},subscribe:$,unsubscribe:M,refresh:O}}};return{namespaceObj:s}},ut={name:"Live Queries",setup:ot};async function pe(e,t){return(await e.query(`
      WITH RECURSIVE view_dependencies AS (
        -- Base case: Get the initial view's dependencies
        SELECT DISTINCT
          cl.relname AS dependent_name,
          n.nspname AS schema_name,
          cl.relkind = 'v' AS is_view
        FROM pg_rewrite r
        JOIN pg_depend d ON r.oid = d.objid
        JOIN pg_class cl ON d.refobjid = cl.oid
        JOIN pg_namespace n ON cl.relnamespace = n.oid
        WHERE
          r.ev_class = (
              SELECT oid FROM pg_class WHERE relname = $1 AND relkind = 'v'
          )
          AND d.deptype = 'n'

        UNION ALL

        -- Recursive case: Traverse dependencies for views
        SELECT DISTINCT
          cl.relname AS dependent_name,
          n.nspname AS schema_name,
          cl.relkind = 'v' AS is_view
        FROM view_dependencies vd
        JOIN pg_rewrite r ON vd.dependent_name = (
          SELECT relname FROM pg_class WHERE oid = r.ev_class AND relkind = 'v'
        )
        JOIN pg_depend d ON r.oid = d.objid
        JOIN pg_class cl ON d.refobjid = cl.oid
        JOIN pg_namespace n ON cl.relnamespace = n.oid
        WHERE d.deptype = 'n'
      )
      SELECT DISTINCT
        dependent_name AS table_name,
        schema_name
      FROM view_dependencies
      WHERE NOT is_view; -- Exclude intermediate views
    `,[t])).rows.map(s=>({table_name:s.table_name,schema_name:s.schema_name}))}async function fe(e,t,n){let s=t.filter(r=>!n.has(`${r.schema_name}_${r.table_name}`)).map(r=>`
      CREATE OR REPLACE FUNCTION "_notify_${r.schema_name}_${r.table_name}"() RETURNS TRIGGER AS $$
      BEGIN
        PERFORM pg_notify('table_change__${r.schema_name}__${r.table_name}', '');
        RETURN NULL;
      END;
      $$ LANGUAGE plpgsql;
      CREATE OR REPLACE TRIGGER "_notify_trigger_${r.schema_name}_${r.table_name}"
      AFTER INSERT OR UPDATE OR DELETE ON "${r.schema_name}"."${r.table_name}"
      FOR EACH STATEMENT EXECUTE FUNCTION "_notify_${r.schema_name}_${r.table_name}"();
      `).join(`
`);s.trim()!==""&&await e.exec(s),t.map(r=>n.add(`${r.schema_name}_${r.table_name}`))}var z=(e,t)=>{for(let n of e)n(t)},lt=(e,t)=>{for(let n of e)n(t)};0&&(module.exports={live});
//# sourceMappingURL=index.cjs.map