fix: correctly infer nullable fields from LEFT JOIN LATERAL (#425)

Author: Newbie012

.changeset/bright-cows-lose.md

@@ -0,0 +1,5 @@
+---
+"@ts-safeql/eslint-plugin": patch
+---
+
+Fixed an issue where fields from LEFT JOIN LATERAL subqueries were incorrectly inferred as non-nullable.

packages/generate/src/ast-get-sources.ts

@@ -314,7 +314,12 @@ export function getSources({
         case "cte":
         case "subselect": {
           const nested = source.sources.getNestedResolvedTargetField(field);
-          if (nested) return nested;
+          if (nested) {
+            return {
+              ...nested,
+              isNotNull: nested.isNotNull && !checkIsNullableDueToRelation(source.name),
+            };
+          }
           break;
         }
         case "table": {
@@ -342,7 +347,15 @@ export function getSources({
           switch (source.kind) {
             case "subselect": {
               const column = source.sources.getNestedResolvedTargetField(field);
-              if (column) return [column];
+              if (column) {
+                // Check if this subselect is part of a LEFT JOIN or FULL JOIN
+                const isNullableDueToRelation = checkIsNullableDueToRelation(source.name);
+                if (isNullableDueToRelation && column.isNotNull) {
+                  // Make the column nullable if it's from a left/full joined subselect
+                  return [{ ...column, isNotNull: false }];
+                }
+                return [column];
+              }
               break;
             }
             default:
@@ -367,7 +380,17 @@ export function getSources({
         for (const source of sources.values()) {
           switch (source.kind) {
             case "subselect": {
-              return source.sources.getColumnsByTargetField(field);
+              const columns = source.sources.getColumnsByTargetField(field);
+              if (columns) {
+                // Check if this subselect is part of a LEFT JOIN or FULL JOIN
+                const isNullableDueToRelation = checkIsNullableDueToRelation(source.name);
+                if (isNullableDueToRelation) {
+                  // Make columns nullable if they're from a left/full joined subselect
+                  return columns.map((col) => (col.isNotNull ? { ...col, isNotNull: false } : col));
+                }
+                return columns;
+              }
+              break;
             }
 
             default:

packages/generate/src/generate.test.ts

@@ -2350,3 +2350,96 @@ test("scalar subquery with WHERE should infer non-nullable type", async () => {
     expected: [["col", { kind: "type", value: "string", type: "text" }]],
   });
 });
+
+test("select from LEFT JOIN LATERAL should return nullable field", async () => {
+  await testQuery({
+    schema: `
+      CREATE TABLE parent_table (id INTEGER PRIMARY KEY);
+      CREATE TABLE child_table (
+        parent_id INTEGER REFERENCES parent_table(id),
+        status BOOLEAN NOT NULL
+      );
+    `,
+    query: `
+      SELECT
+        latest_child.status AS latest_status
+      FROM
+        parent_table
+        LEFT JOIN LATERAL (
+          SELECT child_table.status
+          FROM child_table
+          WHERE child_table.parent_id = parent_table.id
+        ) latest_child ON TRUE
+    `,
+    expected: [
+      [
+        "latest_status",
+        {
+          kind: "union",
+          value: [
+            { kind: "type", value: "boolean", type: "bool" },
+            { kind: "type", value: "null", type: "null" },
+          ],
+        },
+      ],
+    ],
+  });
+});
+
+test("nullable columns in regular subselect should remain nullable", async () => {
+  await testQuery({
+    schema: `
+      CREATE TABLE test_table (
+        id INTEGER PRIMARY KEY,
+        nullable_text TEXT,
+        non_null_text TEXT NOT NULL
+      );
+    `,
+    query: `
+      SELECT nullable_text, non_null_text
+      FROM (SELECT nullable_text, non_null_text FROM test_table) sub
+    `,
+    expected: [
+      [
+        "nullable_text",
+        {
+          kind: "union",
+          value: [
+            { kind: "type", value: "string", type: "text" },
+            { kind: "type", value: "null", type: "null" },
+          ],
+        },
+      ],
+      ["non_null_text", { kind: "type", value: "string", type: "text" }],
+    ],
+  });
+});
+
+test("nullable columns in INNER JOIN subselect should remain nullable", async () => {
+  await testQuery({
+    schema: `
+      CREATE TABLE table_a (id INTEGER PRIMARY KEY);
+      CREATE TABLE table_b (
+        id INTEGER PRIMARY KEY,
+        nullable_col TEXT
+      );
+    `,
+    query: `
+      SELECT sub.nullable_col
+      FROM table_a
+      INNER JOIN (SELECT id, nullable_col FROM table_b) sub ON sub.id = table_a.id
+    `,
+    expected: [
+      [
+        "nullable_col",
+        {
+          kind: "union",
+          value: [
+            { kind: "type", value: "string", type: "text" },
+            { kind: "type", value: "null", type: "null" },
+          ],
+        },
+      ],
+    ],
+  });
+});

packages/generate/src/utils/get-relations-with-joins.test.ts

@@ -113,6 +113,23 @@ const cases: {
       ],
     ],
   },
+  {
+    query: `
+      SELECT latest.status
+      FROM parent_table
+        LEFT JOIN LATERAL (
+          SELECT child_table.status
+          FROM child_table
+          WHERE child_table.parent_id = parent_table.id
+        ) latest ON TRUE
+    `,
+    expected: [
+      [
+        "parent_table",
+        [{ alias: undefined, name: "latest", type: LibPgQueryAST.JoinType.JOIN_LEFT }],
+      ],
+    ],
+  },
 ];
 
 export const getRelationsWithJoinsTE = flow(