feat(plpgsql-parser): automatically compute return info for correct RETURN handling

The deparser now automatically extracts return type information from the
CreateFunctionStmt and passes it to the PL/pgSQL deparser. This ensures
correct RETURN statement handling without users needing to manually
provide return context:

- SETOF functions: bare RETURN stays as RETURN
- Scalar functions: empty RETURN becomes RETURN NULL
- Void functions: bare RETURN stays as RETURN
- Trigger functions: handled correctly
- OUT parameter functions: bare RETURN stays as RETURN

Added 5 tests to verify automatic return info handling works correctly.

Author: pyramation

packages/plpgsql-parser/__tests__/plpgsql-parser.test.ts

@@ -111,4 +111,102 @@ describe('plpgsql-parser', () => {
       expect(result).toContain('\n');
     });
   });
+
+  describe('automatic return info handling', () => {
+    it('should preserve bare RETURN for SETOF functions', () => {
+      const setofSql = `
+        CREATE FUNCTION get_users()
+        RETURNS SETOF users
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          RETURN QUERY SELECT * FROM users;
+          RETURN;
+        END;
+        $$;
+      `;
+      
+      const parsed = parse(setofSql);
+      const result = deparseSync(parsed);
+      
+      // SETOF functions should keep bare RETURN (not RETURN NULL)
+      expect(result).toMatch(/RETURN\s*;/);
+      expect(result).not.toMatch(/RETURN\s+NULL\s*;/);
+    });
+
+    it('should emit RETURN NULL for scalar functions with empty return', () => {
+      const scalarSql = `
+        CREATE FUNCTION get_value()
+        RETURNS int
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          RETURN;
+        END;
+        $$;
+      `;
+      
+      const parsed = parse(scalarSql);
+      const result = deparseSync(parsed);
+      
+      // Scalar functions with empty RETURN should become RETURN NULL
+      expect(result).toMatch(/RETURN\s+NULL\s*;/);
+    });
+
+    it('should preserve bare RETURN for void functions', () => {
+      const voidSql = `
+        CREATE FUNCTION do_something()
+        RETURNS void
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          RAISE NOTICE 'done';
+          RETURN;
+        END;
+        $$;
+      `;
+      
+      const parsed = parse(voidSql);
+      const result = deparseSync(parsed);
+      
+      // Void functions should keep bare RETURN
+      expect(result).toMatch(/RETURN\s*;/);
+      expect(result).not.toMatch(/RETURN\s+NULL\s*;/);
+    });
+
+    it('should preserve bare RETURN for trigger functions', () => {
+      const triggerSql = `
+        CREATE FUNCTION my_trigger()
+        RETURNS trigger
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          RETURN NEW;
+        END;
+        $$;
+      `;
+      
+      const parsed = parse(triggerSql);
+      const result = deparseSync(parsed);
+      
+      // Trigger functions should work correctly (case-insensitive check)
+      expect(result.toLowerCase()).toContain('return new');
+    });
+
+    it('should preserve bare RETURN for OUT parameter functions', () => {
+      const outParamSql = `
+        CREATE FUNCTION get_info(OUT result text)
+        RETURNS text
+        LANGUAGE plpgsql AS $$
+        BEGIN
+          result := 'hello';
+          RETURN;
+        END;
+        $$;
+      `;
+      
+      const parsed = parse(outParamSql);
+      const result = deparseSync(parsed);
+      
+      // OUT parameter functions should keep bare RETURN
+      expect(result).toMatch(/RETURN\s*;/);
+      expect(result).not.toMatch(/RETURN\s+NULL\s*;/);
+    });
+  });
 });

packages/plpgsql-parser/src/deparse.ts

@@ -1,14 +1,16 @@
 import { deparse as deparseSql } from 'pgsql-deparser';
 import {
   dehydratePlpgsqlAst,
-  deparseSync as deparsePlpgsql
+  deparseSync as deparsePlpgsql,
+  deparseFunctionSync as deparsePlpgsqlFunction
 } from 'plpgsql-deparser';
 import type {
   ParsedScript,
   TransformContext,
   DeparseOptions,
   ParsedFunction
 } from './types';
+import { getReturnInfoFromParsedFunction } from './return-info';
 
 function stitchBodyIntoSqlAst(
   sqlAst: any,
@@ -48,8 +50,12 @@ export async function deparse(
 
   for (const fn of functions) {
     const dehydrated = dehydratePlpgsqlAst(fn.plpgsql.hydrated);
-    const newBody = deparsePlpgsql(dehydrated);
-    stitchBodyIntoSqlAst(sqlAst, fn, newBody);
+    const returnInfo = getReturnInfoFromParsedFunction(fn);
+    const plpgsqlFunc = dehydrated.plpgsql_funcs?.[0]?.PLpgSQL_function;
+    if (plpgsqlFunc) {
+      const newBody = deparsePlpgsqlFunction(plpgsqlFunc, undefined, returnInfo);
+      stitchBodyIntoSqlAst(sqlAst, fn, newBody);
+    }
   }
 
   if (sqlAst.stmts && sqlAst.stmts.length > 0) {
@@ -77,8 +83,12 @@ export function deparseSync(
 
   for (const fn of functions) {
     const dehydrated = dehydratePlpgsqlAst(fn.plpgsql.hydrated);
-    const newBody = deparsePlpgsql(dehydrated);
-    stitchBodyIntoSqlAst(sqlAst, fn, newBody);
+    const returnInfo = getReturnInfoFromParsedFunction(fn);
+    const plpgsqlFunc = dehydrated.plpgsql_funcs?.[0]?.PLpgSQL_function;
+    if (plpgsqlFunc) {
+      const newBody = deparsePlpgsqlFunction(plpgsqlFunc, undefined, returnInfo);
+      stitchBodyIntoSqlAst(sqlAst, fn, newBody);
+    }
   }
 
   if (sqlAst.stmts && sqlAst.stmts.length > 0) {