@gencow/core 0.1.23 → 0.1.25

package/src/__tests__/validator.test.ts

@@ -7,313 +7,317 @@
  */
 
 import { describe, it, expect } from "bun:test";
-import { v, parseArgs, GencowValidationError } from "../v";
+import { v, parseArgs, GencowValidationError } from "../v.js";
 
 // ─── v.string() ─────────────────────────────────────────
 
 describe("v.string()", () => {
-    const validator = v.string();
+  const validator = v.string();
 
-    it("문자열 통과", () => {
-        expect(validator.parse("hello")).toBe("hello");
-    });
+  it("문자열 통과", () => {
+    expect(validator.parse("hello")).toBe("hello");
+  });
 
-    it("빈 문자열 통과", () => {
-        expect(validator.parse("")).toBe("");
-    });
+  it("빈 문자열 통과", () => {
+    expect(validator.parse("")).toBe("");
+  });
 
-    it("숫자 → 에러", () => {
-        expect(() => validator.parse(42)).toThrow("Expected string");
-    });
+  it("숫자 → 에러", () => {
+    expect(() => validator.parse(42)).toThrow("Expected string");
+  });
 
-    it("불리언 → 에러", () => {
-        expect(() => validator.parse(true)).toThrow("Expected string");
-    });
+  it("불리언 → 에러", () => {
+    expect(() => validator.parse(true)).toThrow("Expected string");
+  });
 
-    it("null → 에러", () => {
-        expect(() => validator.parse(null)).toThrow("Expected string");
-    });
+  it("null → 에러", () => {
+    expect(() => validator.parse(null)).toThrow("Expected string");
+  });
 
-    it("undefined → 에러", () => {
-        expect(() => validator.parse(undefined)).toThrow("Expected string");
-    });
+  it("undefined → 에러", () => {
+    expect(() => validator.parse(undefined)).toThrow("Expected string");
+  });
 });
 
 // ─── v.number() ─────────────────────────────────────────
 
 describe("v.number()", () => {
-    const validator = v.number();
+  const validator = v.number();
 
-    it("정수 통과", () => {
-        expect(validator.parse(42)).toBe(42);
-    });
+  it("정수 통과", () => {
+    expect(validator.parse(42)).toBe(42);
+  });
 
-    it("실수 통과", () => {
-        expect(validator.parse(3.14)).toBe(3.14);
-    });
+  it("실수 통과", () => {
+    expect(validator.parse(3.14)).toBe(3.14);
+  });
 
-    it("0 통과", () => {
-        expect(validator.parse(0)).toBe(0);
-    });
+  it("0 통과", () => {
+    expect(validator.parse(0)).toBe(0);
+  });
 
-    it("음수 통과", () => {
-        expect(validator.parse(-10)).toBe(-10);
-    });
+  it("음수 통과", () => {
+    expect(validator.parse(-10)).toBe(-10);
+  });
 
-    it("숫자 문자열 → 자동 변환", () => {
-        expect(validator.parse("42")).toBe(42);
-    });
+  it("숫자 문자열 → 자동 변환", () => {
+    expect(validator.parse("42")).toBe(42);
+  });
 
-    it("비숫자 문자열 → 에러", () => {
-        expect(() => validator.parse("abc")).toThrow("Expected number");
-    });
+  it("비숫자 문자열 → 에러", () => {
+    expect(() => validator.parse("abc")).toThrow("Expected number");
+  });
 
-    it("불리언 → 에러", () => {
-        expect(() => validator.parse(true)).toThrow("Expected number");
-    });
+  it("불리언 → 에러", () => {
+    expect(() => validator.parse(true)).toThrow("Expected number");
+  });
 
-    it("NaN 입력 → 에러", () => {
-        expect(() => validator.parse(NaN)).toThrow("Expected number");
-    });
+  it("NaN 입력 → 에러", () => {
+    expect(() => validator.parse(NaN)).toThrow("Expected number");
+  });
 });
 
 // ─── v.boolean() ────────────────────────────────────────
 
 describe("v.boolean()", () => {
-    const validator = v.boolean();
+  const validator = v.boolean();
 
-    it("true 통과", () => {
-        expect(validator.parse(true)).toBe(true);
-    });
+  it("true 통과", () => {
+    expect(validator.parse(true)).toBe(true);
+  });
 
-    it("false 통과", () => {
-        expect(validator.parse(false)).toBe(false);
-    });
+  it("false 통과", () => {
+    expect(validator.parse(false)).toBe(false);
+  });
 
-    it("문자열 → 에러", () => {
-        expect(() => validator.parse("true")).toThrow("Expected boolean");
-    });
+  it("문자열 → 에러", () => {
+    expect(() => validator.parse("true")).toThrow("Expected boolean");
+  });
 
-    it("숫자 → 에러", () => {
-        expect(() => validator.parse(1)).toThrow("Expected boolean");
-    });
+  it("숫자 → 에러", () => {
+    expect(() => validator.parse(1)).toThrow("Expected boolean");
+  });
 });
 
 // ─── v.any() ────────────────────────────────────────────
 
 describe("v.any()", () => {
-    const validator = v.any();
+  const validator = v.any();
 
-    it("모든 값 통과 — 문자열", () => {
-        expect(validator.parse("hello")).toBe("hello");
-    });
+  it("모든 값 통과 — 문자열", () => {
+    expect(validator.parse("hello")).toBe("hello");
+  });
 
-    it("모든 값 통과 — 숫자", () => {
-        expect(validator.parse(42)).toBe(42);
-    });
+  it("모든 값 통과 — 숫자", () => {
+    expect(validator.parse(42)).toBe(42);
+  });
 
-    it("모든 값 통과 — null", () => {
-        expect(validator.parse(null)).toBe(null);
-    });
+  it("모든 값 통과 — null", () => {
+    expect(validator.parse(null)).toBe(null);
+  });
 
-    it("모든 값 통과 — undefined", () => {
-        expect(validator.parse(undefined)).toBe(undefined);
-    });
+  it("모든 값 통과 — undefined", () => {
+    expect(validator.parse(undefined)).toBe(undefined);
+  });
 
-    it("모든 값 통과 — 객체", () => {
-        const obj = { key: "value" };
-        expect(validator.parse(obj)).toBe(obj);
-    });
+  it("모든 값 통과 — 객체", () => {
+    const obj = { key: "value" };
+    expect(validator.parse(obj)).toBe(obj);
+  });
 });
 
 // ─── v.optional() ───────────────────────────────────────
 
 describe("v.optional()", () => {
-    const validator = v.optional(v.string());
+  const validator = v.optional(v.string());
 
-    it("문자열 통과", () => {
-        expect(validator.parse("hello")).toBe("hello");
-    });
+  it("문자열 통과", () => {
+    expect(validator.parse("hello")).toBe("hello");
+  });
 
-    it("undefined → undefined 반환", () => {
-        expect(validator.parse(undefined)).toBe(undefined);
-    });
+  it("undefined → undefined 반환", () => {
+    expect(validator.parse(undefined)).toBe(undefined);
+  });
 
-    it("null → undefined 반환", () => {
-        expect(validator.parse(null)).toBe(undefined);
-    });
+  it("null → undefined 반환", () => {
+    expect(validator.parse(null)).toBe(undefined);
+  });
 
-    it("숫자 → 에러 (내부 validator 적용)", () => {
-        expect(() => validator.parse(42)).toThrow("Expected string");
-    });
+  it("숫자 → 에러 (내부 validator 적용)", () => {
+    expect(() => validator.parse(42)).toThrow("Expected string");
+  });
 });
 
 // ─── v.array() ──────────────────────────────────────────
 
 describe("v.array()", () => {
-    const validator = v.array(v.string());
+  const validator = v.array(v.string());
 
-    it("문자열 배열 통과", () => {
-        expect(validator.parse(["a", "b", "c"])).toEqual(["a", "b", "c"]);
-    });
+  it("문자열 배열 통과", () => {
+    expect(validator.parse(["a", "b", "c"])).toEqual(["a", "b", "c"]);
+  });
 
-    it("빈 배열 통과", () => {
-        expect(validator.parse([])).toEqual([]);
-    });
+  it("빈 배열 통과", () => {
+    expect(validator.parse([])).toEqual([]);
+  });
 
-    it("비배열 → 에러", () => {
-        expect(() => validator.parse("not array")).toThrow("Expected array");
-    });
+  it("비배열 → 에러", () => {
+    expect(() => validator.parse("not array")).toThrow("Expected array");
+  });
 
-    it("원소 타입 불일치 → 에러", () => {
-        expect(() => validator.parse([1, 2, 3])).toThrow("Expected string");
-    });
+  it("원소 타입 불일치 → 에러", () => {
+    expect(() => validator.parse([1, 2, 3])).toThrow("Expected string");
+  });
 
-    it("혼합 배열 → 에러", () => {
-        expect(() => validator.parse(["ok", 42])).toThrow("Expected string");
-    });
+  it("혼합 배열 → 에러", () => {
+    expect(() => validator.parse(["ok", 42])).toThrow("Expected string");
+  });
 });
 
 // ─── v.object() ─────────────────────────────────────────
 
 describe("v.object()", () => {
-    const validator = v.object({
-        name: v.string(),
-        age: v.number(),
-    });
-
-    it("유효한 객체 통과", () => {
-        expect(validator.parse({ name: "Alice", age: 30 })).toEqual({ name: "Alice", age: 30 });
-    });
-
-    it("비객체 → 에러", () => {
-        expect(() => validator.parse("string")).toThrow("Expected object");
-    });
-
-    it("null → 에러", () => {
-        expect(() => validator.parse(null)).toThrow("Expected object");
-    });
-
-    it("필드 타입 불일치 → 에러", () => {
-        expect(() => validator.parse({ name: 42, age: 30 })).toThrow("Expected string");
-    });
-
-    it("필드 누락 → inner validator 에러", () => {
-        expect(() => validator.parse({ name: "Alice" })).toThrow("Expected number");
-    });
+  const validator = v.object({
+    name: v.string(),
+    age: v.number(),
+  });
+
+  it("유효한 객체 통과", () => {
+    expect(validator.parse({ name: "Alice", age: 30 })).toEqual({ name: "Alice", age: 30 });
+  });
+
+  it("비객체 → 에러", () => {
+    expect(() => validator.parse("string")).toThrow("Expected object");
+  });
+
+  it("null → 에러", () => {
+    expect(() => validator.parse(null)).toThrow("Expected object");
+  });
+
+  it("필드 타입 불일치 → 에러", () => {
+    expect(() => validator.parse({ name: 42, age: 30 })).toThrow("Expected string");
+  });
+
+  it("필드 누락 → inner validator 에러", () => {
+    expect(() => validator.parse({ name: "Alice" })).toThrow("Expected number");
+  });
 });
 
 // ─── 복합 중첩 검증 ────────────────────────────────────
 
 describe("복합 중첩 검증", () => {
-    it("v.optional(v.array(v.string()))", () => {
-        const validator = v.optional(v.array(v.string()));
-        expect(validator.parse(undefined)).toBe(undefined);
-        expect(validator.parse(["a", "b"])).toEqual(["a", "b"]);
-        expect(() => validator.parse([1])).toThrow("Expected string");
-    });
-
-    it("v.array(v.object(...))", () => {
-        const validator = v.array(v.object({
-            id: v.number(),
-            label: v.string(),
-        }));
-        expect(validator.parse([
-            { id: 1, label: "A" },
-            { id: 2, label: "B" },
-        ])).toEqual([
-            { id: 1, label: "A" },
-            { id: 2, label: "B" },
-        ]);
-    });
-
-    it("v.object({ tags: v.array(v.string()), meta: v.optional(v.object(...)) })", () => {
-        const validator = v.object({
-            tags: v.array(v.string()),
-            meta: v.optional(v.object({ key: v.string() })),
-        });
-        expect(validator.parse({ tags: ["a"], meta: undefined })).toEqual({ tags: ["a"], meta: undefined });
-        expect(validator.parse({ tags: [], meta: { key: "val" } })).toEqual({ tags: [], meta: { key: "val" } });
+  it("v.optional(v.array(v.string()))", () => {
+    const validator = v.optional(v.array(v.string()));
+    expect(validator.parse(undefined)).toBe(undefined);
+    expect(validator.parse(["a", "b"])).toEqual(["a", "b"]);
+    expect(() => validator.parse([1])).toThrow("Expected string");
+  });
+
+  it("v.array(v.object(...))", () => {
+    const validator = v.array(
+      v.object({
+        id: v.number(),
+        label: v.string(),
+      }),
+    );
+    expect(
+      validator.parse([
+        { id: 1, label: "A" },
+        { id: 2, label: "B" },
+      ]),
+    ).toEqual([
+      { id: 1, label: "A" },
+      { id: 2, label: "B" },
+    ]);
+  });
+
+  it("v.object({ tags: v.array(v.string()), meta: v.optional(v.object(...)) })", () => {
+    const validator = v.object({
+      tags: v.array(v.string()),
+      meta: v.optional(v.object({ key: v.string() })),
     });
+    expect(validator.parse({ tags: ["a"], meta: undefined })).toEqual({ tags: ["a"], meta: undefined });
+    expect(validator.parse({ tags: [], meta: { key: "val" } })).toEqual({ tags: [], meta: { key: "val" } });
+  });
 });
 
 // ─── parseArgs() ────────────────────────────────────────
 
 describe("parseArgs()", () => {
-    it("schema 없으면 args 그대로 반환", () => {
-        expect(parseArgs(null, { foo: 1 })).toEqual({ foo: 1 });
-        expect(parseArgs(undefined, "hello")).toBe("hello");
-    });
-
-    it("Validator 스키마로 직접 파싱", () => {
-        const schema = v.string();
-        expect(parseArgs(schema, "hello")).toBe("hello");
-    });
-
-    it("Validator 스키마 검증 실패 → GencowValidationError", () => {
-        const schema = v.string();
-        expect(() => parseArgs(schema, 42)).toThrow(GencowValidationError);
-    });
-
-    it("Shorthand record 스키마 (Convex 스타일)", () => {
-        const schema = { title: v.string(), count: v.number() };
-        expect(parseArgs(schema, { title: "Hello", count: 5 })).toEqual({ title: "Hello", count: 5 });
-    });
-
-    it("Shorthand record 검증 실패 → GencowValidationError + 필드명 포함", () => {
-        const schema = { title: v.string(), count: v.number() };
-        try {
-            parseArgs(schema, { title: 42, count: 5 });
-            expect(true).toBe(false); // 여기 도달하면 안 됨
-        } catch (e) {
-            expect(e).toBeInstanceOf(GencowValidationError);
-            expect((e as Error).message).toContain("title");
-        }
-    });
-
-    it("Shorthand record에 비객체 전달 → GencowValidationError", () => {
-        const schema = { title: v.string() };
-        expect(() => parseArgs(schema, "not an object")).toThrow(GencowValidationError);
-    });
-
-    it("GencowValidationError.statusCode === 400", () => {
-        const err = new GencowValidationError("test");
-        expect(err.statusCode).toBe(400);
-        expect(err.name).toBe("GencowValidationError");
-    });
-
-    // ─── 빈 스키마 passthrough (FormData 업로드 버그 회귀 방지) ────
-
-    it("빈 스키마 {} → args 전체 passthrough (FormData file 필드 보존)", () => {
-        const schema = {};
-        const args = { file: new File(["hello"], "test.txt"), _mutation: "upload.store" };
-        const result = parseArgs(schema, args);
-        // 빈 스키마이므로 args가 그대로 반환되어야 함 (file 포함)
-        expect(result).toBe(args); // 참조 동일
-        expect(result.file).toBeInstanceOf(File);
-        expect(result._mutation).toBe("upload.store");
-    });
-
-    it("빈 스키마 {} + 일반 객체 → passthrough", () => {
-        const schema = {};
-        const args = { name: "test", count: 42, nested: { a: 1 } };
-        const result = parseArgs(schema, args);
-        expect(result).toBe(args);
-        expect(result.name).toBe("test");
-        expect(result.count).toBe(42);
-    });
-
-    it("빈 스키마 {} + 빈 args {} → 빈 객체 반환", () => {
-        const result = parseArgs({}, {});
-        expect(result).toEqual({});
-    });
-
-    it("키가 있는 스키마는 여전히 지정된 키만 추출 (file 제거됨)", () => {
-        const schema = { title: v.string() };
-        const args = { title: "hello", file: "should-be-stripped", extra: 123 };
-        const result = parseArgs(schema, args);
-        expect(result).toEqual({ title: "hello" });
-        expect(result.file).toBeUndefined();
-        expect(result.extra).toBeUndefined();
-    });
+  it("schema 없으면 args 그대로 반환", () => {
+    expect(parseArgs(null, { foo: 1 })).toEqual({ foo: 1 });
+    expect(parseArgs(undefined, "hello")).toBe("hello");
+  });
+
+  it("Validator 스키마로 직접 파싱", () => {
+    const schema = v.string();
+    expect(parseArgs(schema, "hello")).toBe("hello");
+  });
+
+  it("Validator 스키마 검증 실패 → GencowValidationError", () => {
+    const schema = v.string();
+    expect(() => parseArgs(schema, 42)).toThrow(GencowValidationError);
+  });
+
+  it("Shorthand record 스키마 (Convex 스타일)", () => {
+    const schema = { title: v.string(), count: v.number() };
+    expect(parseArgs(schema, { title: "Hello", count: 5 })).toEqual({ title: "Hello", count: 5 });
+  });
+
+  it("Shorthand record 검증 실패 → GencowValidationError + 필드명 포함", () => {
+    const schema = { title: v.string(), count: v.number() };
+    try {
+      parseArgs(schema, { title: 42, count: 5 });
+      expect(true).toBe(false); // 여기 도달하면 안 됨
+    } catch (e) {
+      expect(e).toBeInstanceOf(GencowValidationError);
+      expect((e as Error).message).toContain("title");
+    }
+  });
+
+  it("Shorthand record에 비객체 전달 → GencowValidationError", () => {
+    const schema = { title: v.string() };
+    expect(() => parseArgs(schema, "not an object")).toThrow(GencowValidationError);
+  });
+
+  it("GencowValidationError.statusCode === 400", () => {
+    const err = new GencowValidationError("test");
+    expect(err.statusCode).toBe(400);
+    expect(err.name).toBe("GencowValidationError");
+  });
+
+  // ─── 빈 스키마 passthrough (FormData 업로드 버그 회귀 방지) ────
+
+  it("빈 스키마 {} → args 전체 passthrough (FormData file 필드 보존)", () => {
+    const schema = {};
+    const args = { file: new File(["hello"], "test.txt"), _mutation: "upload.store" };
+    const result = parseArgs(schema, args);
+    // 빈 스키마이므로 args가 그대로 반환되어야 함 (file 포함)
+    expect(result).toBe(args); // 참조 동일
+    expect(result.file).toBeInstanceOf(File);
+    expect(result._mutation).toBe("upload.store");
+  });
+
+  it("빈 스키마 {} + 일반 객체 → passthrough", () => {
+    const schema = {};
+    const args = { name: "test", count: 42, nested: { a: 1 } };
+    const result = parseArgs(schema, args);
+    expect(result).toBe(args);
+    expect(result.name).toBe("test");
+    expect(result.count).toBe(42);
+  });
+
+  it("빈 스키마 {} + 빈 args {} → 빈 객체 반환", () => {
+    const result = parseArgs({}, {});
+    expect(result).toEqual({});
+  });
+
+  it("키가 있는 스키마는 여전히 지정된 키만 추출 (file 제거됨)", () => {
+    const schema = { title: v.string() };
+    const args = { title: "hello", file: "should-be-stripped", extra: 123 };
+    const result = parseArgs(schema, args);
+    expect(result).toEqual({ title: "hello" });
+    expect(result.file).toBeUndefined();
+    expect(result.extra).toBeUndefined();
+  });
 });