sonamu 0.7.4 → 0.7.6

package/src/database/puri.types.test-d.ts

@@ -0,0 +1,457 @@
+import { describe, expectTypeOf, it } from "vitest";
+import type {
+  AvailableColumns,
+  ExtractColumnType,
+  LeftJoinedMarker,
+  ParseSelectObject,
+} from "./puri.types";
+
+// ============================================================================
+// 테스트용 Mock 스키마
+// ============================================================================
+
+type MockSchema = {
+  users: {
+    id: number;
+    name: string;
+    email: string;
+    department_id: number | null;
+  };
+  departments: {
+    id: number;
+    name: string;
+    company_id: number;
+  };
+  companies: {
+    id: number;
+    name: string;
+  };
+  employees: {
+    id: number;
+    employee_number: string;
+    salary: string | null; // nullable 필드
+    user_id: number;
+    department_id: number | null;
+  };
+};
+
+// ============================================================================
+// ExtractColumnType 테스트
+// ============================================================================
+
+describe("ExtractColumnType", () => {
+  describe("단일 테이블", () => {
+    it("기본 컬럼 타입을 추출한다", () => {
+      type Tables = { users: MockSchema["users"] };
+      type Result = ExtractColumnType<Tables, "users.id">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<number>();
+    });
+
+    it("nullable 컬럼 타입을 추출한다", () => {
+      type Tables = { users: MockSchema["users"] };
+      type Result = ExtractColumnType<Tables, "users.department_id">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<number | null>();
+    });
+
+    it("단일 테이블에서는 테이블명 없이 컬럼명만으로 추출 가능하다", () => {
+      type Tables = { users: MockSchema["users"] };
+      type Result = ExtractColumnType<Tables, "id">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<number>();
+    });
+  });
+
+  describe("innerJoin된 테이블", () => {
+    it("innerJoin 테이블의 컬럼은 non-null이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"]; // innerJoin
+      };
+      type Result = ExtractColumnType<Tables, "department.id">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<number>();
+    });
+  });
+
+  describe("leftJoin된 테이블", () => {
+    it("leftJoin 테이블의 컬럼은 nullable이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"] & LeftJoinedMarker; // leftJoin
+      };
+      type Result = ExtractColumnType<Tables, "department.id">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<number | null>();
+    });
+
+    it("leftJoin 테이블의 원래 nullable 컬럼도 nullable이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        employee: MockSchema["employees"] & LeftJoinedMarker; // leftJoin
+      };
+      type Result = ExtractColumnType<Tables, "employee.salary">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<string | null>();
+    });
+  });
+
+  describe("non-null FK로 leftJoin된 테이블", () => {
+    it("non-null FK로 leftJoin된 테이블의 컬럼은 non-null이다 (마커 없음)", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"] & LeftJoinedMarker; // nullable FK
+        company: MockSchema["companies"] & LeftJoinedMarker; // non-null FK → 마커 없음
+      };
+      type Result = ExtractColumnType<Tables, "company.id">;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<number>();
+    });
+  });
+});
+
+// ============================================================================
+// ParseSelectObject 테스트
+// ============================================================================
+
+describe("ParseSelectObject", () => {
+  describe("단일 테이블 (flat select)", () => {
+    it("기본 필드를 파싱한다", () => {
+      type Tables = { users: MockSchema["users"] };
+      type Select = {
+        id: "users.id";
+        name: "users.name";
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        name: string;
+      }>();
+    });
+
+    it("nullable 필드를 파싱한다", () => {
+      type Tables = { users: MockSchema["users"] };
+      type Select = {
+        id: "users.id";
+        department_id: "users.department_id";
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        department_id: number | null;
+      }>();
+    });
+  });
+
+  describe("innerJoin + flat select", () => {
+    it("innerJoin 테이블의 필드는 non-null이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"]; // innerJoin
+      };
+      type Select = {
+        id: "users.id";
+        dept_id: "department.id";
+        dept_name: "department.name";
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        dept_id: number;
+        dept_name: string;
+      }>();
+    });
+  });
+
+  describe("leftJoin + flat select", () => {
+    it("leftJoin 테이블의 필드는 nullable이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"] & LeftJoinedMarker; // leftJoin
+      };
+      type Select = {
+        id: "users.id";
+        dept_id: "department.id";
+        dept_name: "department.name";
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        dept_id: number | null;
+        dept_name: string | null;
+      }>();
+    });
+  });
+
+  // ============================================================================
+  // 핵심: 입체적 select 구조
+  // ============================================================================
+
+  describe("innerJoin + nested select (입체적 구조)", () => {
+    it("innerJoin 테이블의 중첩 객체는 non-null이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"]; // innerJoin
+      };
+      type Select = {
+        id: "users.id";
+        department: {
+          id: "department.id";
+          name: "department.name";
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        department: {
+          id: number;
+          name: string;
+        };
+      }>();
+    });
+  });
+
+  describe("leftJoin + nested select (입체적 구조)", () => {
+    it("leftJoin 테이블의 중첩 객체는 nullable이다 (필드는 non-null)", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"] & LeftJoinedMarker; // leftJoin
+      };
+      type Select = {
+        id: "users.id";
+        department: {
+          id: "department.id";
+          name: "department.name";
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        department: {
+          id: number;
+          name: string;
+        } | null; // 객체 단위로 nullable
+      }>();
+    });
+
+    it("leftJoin 테이블 내의 원래 nullable 필드도 non-null이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        employee: MockSchema["employees"] & LeftJoinedMarker; // leftJoin
+      };
+      type Select = {
+        id: "users.id";
+        employee: {
+          id: "employee.id";
+          salary: "employee.salary"; // 스키마상 nullable이지만...
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      // employee 객체가 null이 아닐 때만 접근하므로, salary의 원래 nullability 유지
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        employee: {
+          id: number;
+          salary: string | null; // 스키마의 원래 nullability 유지
+        } | null;
+      }>();
+    });
+  });
+
+  describe("non-null FK leftJoin + nested select (입체적 구조)", () => {
+    it("non-null FK로 leftJoin된 테이블의 중첩 객체는 non-null이다", () => {
+      type Tables = {
+        users: MockSchema["users"];
+        department: MockSchema["departments"] & LeftJoinedMarker; // nullable FK → 마커 있음
+        department__company: MockSchema["companies"]; // non-null FK → 마커 없음
+      };
+      type Select = {
+        id: "users.id";
+        department: {
+          id: "department.id";
+          name: "department.name";
+          company: {
+            name: "department__company.name";
+          };
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        department: {
+          id: number;
+          name: string;
+          company: {
+            name: string;
+          }; // non-null! (non-null FK로 조인되어 마커 없음)
+        } | null;
+      }>();
+    });
+
+    it("깊은 중첩에서도 non-null FK leftJoin은 non-null이다", () => {
+      type Tables = {
+        employees: MockSchema["employees"];
+        user: MockSchema["users"]; // innerJoin → 마커 없음
+        user__employee: MockSchema["employees"] & LeftJoinedMarker; // nullable FK
+        user__employee__department: MockSchema["departments"]; // non-null FK → 마커 없음
+      };
+      type Select = {
+        id: "employees.id";
+        user: {
+          id: "user.id";
+          employee: {
+            id: "user__employee.id";
+            department: {
+              id: "user__employee__department.id";
+            };
+          };
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        user: {
+          // user는 innerJoin이므로 무조건 존재합니다.
+          id: number;
+          employee: {
+            // user의 employee는 nullable FK leftJoin이므로 null일 수 있습니다.
+            id: number;
+            department: {
+              // employee가 존재한다면 department는 non-null FK leftJoin이므로 무조건 존재합니다.
+              id: number;
+            }; // non-null FK → non-null
+          } | null; // nullable FK leftJoin → nullable
+        }; // innerJoin → non-null
+      }>();
+    });
+  });
+
+  describe("복합 케이스", () => {
+    it("innerJoin + nullable FK leftJoin + non-null FK leftJoin 조합", () => {
+      type Tables = {
+        employees: MockSchema["employees"];
+        user: MockSchema["users"]; // innerJoin (non-null FK)
+        department: MockSchema["departments"] & LeftJoinedMarker; // nullable FK leftJoin
+        department__company: MockSchema["companies"]; // non-null FK leftJoin → 마커 없음
+      };
+      type Select = {
+        id: "employees.id";
+        employee_number: "employees.employee_number";
+        salary: "employees.salary";
+        user: {
+          id: "user.id";
+          username: "user.name";
+        };
+        department: {
+          id: "department.id";
+          name: "department.name";
+          company: {
+            name: "department__company.name";
+          };
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        employee_number: string;
+        salary: string | null; // 스키마상 nullable
+        user: {
+          id: number;
+          username: string;
+        }; // innerJoin → non-null
+        department: {
+          id: number;
+          name: string;
+          company: {
+            name: string;
+          }; // non-null FK → non-null
+        } | null; // nullable FK leftJoin → nullable
+      }>();
+    });
+
+    it("여러 leftJoin 관계", () => {
+      type Tables = {
+        employees: MockSchema["employees"];
+        department: MockSchema["departments"] & LeftJoinedMarker;
+        manager: MockSchema["users"] & LeftJoinedMarker;
+      };
+      type Select = {
+        id: "employees.id";
+        department: {
+          name: "department.name";
+        };
+        manager: {
+          name: "manager.name";
+        };
+      };
+      type Result = ParseSelectObject<Tables, Select>;
+
+      const result = {} as Result;
+      expectTypeOf(result).toEqualTypeOf<{
+        id: number;
+        department: { name: string } | null;
+        manager: { name: string } | null;
+      }>();
+    });
+  });
+});
+
+// ============================================================================
+// AvailableColumns 테스트
+// ============================================================================
+
+describe("AvailableColumns", () => {
+  it("단일 테이블에서 사용 가능한 컬럼을 추출한다", () => {
+    type Tables = { users: MockSchema["users"] };
+    type Result = AvailableColumns<Tables>;
+
+    // "users.id" | "users.name" | "users.email" | "users.department_id" | "id" | "name" | "email" | "department_id"
+    const valid1: Result = "users.id";
+    const valid2: Result = "id"; // 단일 테이블이면 테이블명 생략 가능
+
+    expectTypeOf(valid1).toExtend<Result>();
+    expectTypeOf(valid2).toExtend<Result>();
+  });
+
+  it("여러 테이블에서 사용 가능한 컬럼을 추출한다", () => {
+    type Tables = {
+      users: MockSchema["users"];
+      department: MockSchema["departments"];
+    };
+    type Result = AvailableColumns<Tables>;
+
+    const valid1: Result = "users.id";
+    const valid2: Result = "department.name";
+
+    expectTypeOf(valid1).toExtend<Result>();
+    expectTypeOf(valid2).toExtend<Result>();
+  });
+});