test(schema) Add tests

Author: brielov

packages/schema/index.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "bun:test";
+import {
+  array,
+  boolean,
+  defaulted,
+  maybe,
+  number,
+  object,
+  SchemaError,
+  string,
+} from ".";
+
+describe("string()", () => {
+  it("should validate a string input", () => {
+    const schema = string();
+    const result = schema.safeParse("hello");
+    expect(result).toEqual({ value: "hello" });
+  });
+
+  it("should reject non-string inputs", () => {
+    const schema = string();
+    const result = schema.safeParse(123);
+    expect(result.issues).toEqual([{ message: "Expected string" }]);
+  });
+
+  it("should throw SchemaError on invalid input when using parse", () => {
+    const schema = string();
+    expect(() => schema.parse(123)).toThrow(SchemaError);
+  });
+});
+
+describe("number()", () => {
+  it("should validate a number input", () => {
+    const schema = number();
+    const result = schema.safeParse(42);
+    expect(result).toEqual({ value: 42 });
+  });
+
+  it("should reject non-number inputs", () => {
+    const schema = number();
+    const result = schema.safeParse("not a number");
+    expect(result.issues).toEqual([{ message: "Expected number" }]);
+  });
+
+  it("should reject NaN and Infinity", () => {
+    const schema = number();
+    expect(schema.safeParse(NaN).issues).toBeDefined();
+    expect(schema.safeParse(Infinity).issues).toBeDefined();
+  });
+});
+
+describe("boolean()", () => {
+  it("should validate a boolean input", () => {
+    const schema = boolean();
+    const result = schema.safeParse(true);
+    expect(result).toEqual({ value: true });
+  });
+
+  it("should reject non-boolean inputs", () => {
+    const schema = boolean();
+    const result = schema.safeParse("not a boolean");
+    expect(result.issues).toEqual([{ message: "Expected boolean" }]);
+  });
+});
+
+describe("array()", () => {
+  it("should validate an array of valid elements", () => {
+    const schema = array(number());
+    const result = schema.safeParse([1, 2, 3]);
+    expect(result).toEqual({ value: [1, 2, 3] });
+  });
+
+  it("should reject non-array inputs", () => {
+    const schema = array(number());
+    const result = schema.safeParse("not an array");
+    expect(result.issues).toEqual([{ message: "Expected array" }]);
+  });
+
+  it("should reject arrays with invalid elements", () => {
+    const schema = array(number());
+    const result = schema.safeParse([1, "not a number", 3]);
+    expect(result.issues).toEqual([{ message: "Expected number", path: [1] }]);
+  });
+});
+
+describe("object()", () => {
+  it("should validate an object with valid properties", () => {
+    const schema = object({
+      name: string(),
+      age: number(),
+    });
+    const result = schema.safeParse({ name: "Alice", age: 30 });
+    expect(result).toEqual({ value: { name: "Alice", age: 30 } });
+  });
+
+  it("should reject non-object inputs", () => {
+    const schema = object({});
+    const result = schema.safeParse("not an object");
+    expect(result.issues).toEqual([{ message: "Expected object" }]);
+  });
+
+  it("should reject objects with invalid properties", () => {
+    const schema = object({
+      name: string(),
+      age: number(),
+    });
+    const result = schema.safeParse({ name: "Alice", age: "not a number" });
+    expect(result.issues).toEqual([
+      { message: "Expected number", path: ["age"] },
+    ]);
+  });
+});
+
+describe("maybe()", () => {
+  it("should allow null or undefined as valid inputs", () => {
+    const schema = maybe(number());
+    expect(schema.safeParse(null)).toEqual({ value: undefined });
+    expect(schema.safeParse(undefined)).toEqual({ value: undefined });
+  });
+
+  it("should validate non-null/undefined inputs", () => {
+    const schema = maybe(number());
+    const result = schema.safeParse(42);
+    expect(result).toEqual({ value: 42 });
+  });
+
+  it("should reject invalid non-null/undefined inputs", () => {
+    const schema = maybe(number());
+    const result = schema.safeParse("not a number");
+    expect(result.issues).toEqual([{ message: "Expected number" }]);
+  });
+});
+
+describe("defaulted()", () => {
+  it("should provide a default value for null or undefined inputs", () => {
+    const schema = defaulted(number(), 42);
+    expect(schema.safeParse(null)).toEqual({ value: 42 });
+    expect(schema.safeParse(undefined)).toEqual({ value: 42 });
+  });
+
+  it("should validate non-null/undefined inputs", () => {
+    const schema = defaulted(number(), 42);
+    const result = schema.safeParse(100);
+    expect(result).toEqual({ value: 100 });
+  });
+
+  it("should reject invalid non-null/undefined inputs", () => {
+    const schema = defaulted(number(), 42);
+    const result = schema.safeParse("not a number");
+    expect(result.issues).toEqual([{ message: "Expected number" }]);
+  });
+});

packages/schema/index.ts

@@ -107,7 +107,7 @@ function prependKeyToIssues(
 ): Issue[] {
   return issues.map((issue) => ({
     ...issue,
-    path: Array.isArray(issue.path) ? [key, ...issue.path] : undefined,
+    path: Array.isArray(issue.path) ? [key, ...issue.path] : [key],
   }));
 }
 
@@ -116,7 +116,7 @@ function prependKeyToIssues(
  * @param message - The error message to return if validation fails.
  * @returns A schema that validates string inputs.
  */
-export function str(message = "Expected string") {
+export function string(message = "Expected string") {
   return createSchema<string>((value) => {
     if ("string" === typeof value) return { value };
     return { issues: [{ message }] };
@@ -128,7 +128,7 @@ export function str(message = "Expected string") {
  * @param message - The error message to return if validation fails.
  * @returns A schema that validates number inputs.
  */
-export function num(message = "Expected number") {
+export function number(message = "Expected number") {
   return createSchema<number>((value) => {
     if ("number" === typeof value && Number.isFinite(value)) return { value };
     return { issues: [{ message }] };
@@ -140,7 +140,7 @@ export function num(message = "Expected number") {
  * @param message - The error message to return if validation fails.
  * @returns A schema that validates boolean inputs.
  */
-export function bool(message = "Expected boolean") {
+export function boolean(message = "Expected boolean") {
   return createSchema<boolean>((value) => {
     if ("boolean" === typeof value) return { value };
     return { issues: [{ message }] };
@@ -154,7 +154,7 @@ export function bool(message = "Expected boolean") {
  * @param message - The error message to return if validation fails.
  * @returns A schema that validates array inputs.
  */
-export function list<T extends Schema>(schema: T, message = "Expected array") {
+export function array<T extends Schema>(schema: T, message = "Expected array") {
   return createSchema<InferOutput<T>[]>((input) => {
     if (!Array.isArray(input)) return { issues: [{ message }] };
     const len = input.length;
@@ -201,7 +201,7 @@ export interface ObjectSchema<TOutput extends RawShape, TInput = unknown>
  * @param message - The error message to return if validation fails.
  * @returns A schema that validates object inputs.
  */
-export function obj<T extends RawShape>(
+export function object<T extends RawShape>(
   shape: ObjectShape<T>,
   message = "Expected object"
 ): ObjectSchema<T> {
@@ -242,7 +242,10 @@ export function maybe<T extends Schema>(schema: T) {
  * @param defaultValue - The default value to use if the input is `null` or `undefined`.
  * @returns A schema that validates inputs and provides a default value if necessary.
  */
-export function def<T extends Schema>(schema: T, defaultValue: InferOutput<T>) {
+export function defaulted<T extends Schema>(
+  schema: T,
+  defaultValue: InferOutput<T>
+) {
   return createSchema<InferOutput<T>>((value) => {
     if (null === value || undefined === value) return { value: defaultValue };
     return schema.safeParse(value);