- add running tests to the CI pipeline (#12)

- small refactor of shared type

.github/workflows/checks.yml

@@ -27,3 +27,6 @@ jobs:
 
       - name: Run check:types
         run: bun check:types
+
+      - name: Run tests
+        run: bun test

package.json

@@ -19,6 +19,7 @@
   },
   "scripts": {
     "build": "tsup",
+    "clean": "rm -rf dist",
     "prettier:write": "prettier --write .",
     "check:lint": "eslint .",
     "check:format": "prettier --check .",

src/arrays.ts

@@ -1,5 +1,5 @@
 import { Fn } from "hotscript";
-import { Validator } from "./shared.types";
+import { Identity, Validator } from "./shared.types";
 
 interface ArrayType extends Fn {
   return: this["args"] extends [...any, infer last]
@@ -54,10 +54,6 @@ export const nonEmpty = () => ({
   },
 });
 
-interface Identity extends Fn {
-  return: this["arg0"];
-}
-
 export const min = (min: number) => ({
   name: "min" as const,
   $inputType: "array" as unknown as [any, ...any[]],

src/object.ts

@@ -1,5 +1,5 @@
 import { Fn } from "hotscript";
-import { Validator } from "./shared.types";
+import { Identity, Validator } from "./shared.types";
 
 interface ObjectSchema extends Fn {
   return: MakeFieldsWithUndefinedOptional<{
@@ -52,10 +52,6 @@ type MakeFieldsWithUndefinedOptional<T> = Expand<
   } & { [K in FieldsWithUndefined<T>]?: T[K] }
 >;
 
-interface Identity extends Fn {
-  return: this["arg0"];
-}
-
 export const passthrough = () => {
   const ctx = {
     chain: null as Validator<any, any> | null,

src/sets.ts

@@ -1,5 +1,5 @@
 import { Fn } from "hotscript";
-import { Validator } from "./shared.types";
+import { Identity, Validator } from "./shared.types";
 
 interface SetType extends Fn {
   return: Set<this["arg1"]["$outputType"]>;
@@ -27,10 +27,6 @@ export const set = <const Schema extends Validator<any, any>>(
   },
 });
 
-interface Identity extends Fn {
-  return: this["arg0"];
-}
-
 export const nonEmpty = () => ({
   name: "nonEmpty" as const,
   $inputType: "set" as unknown as Set<any>,

src/shared.types.ts

@@ -1,3 +1,5 @@
+import { Fn } from "hotscript";
+
 export type Validator<Input, Output> = {
   name: string;
   $inputType: Input;
@@ -17,3 +19,7 @@ export type Primitive =
   | symbol
   | null
   | undefined;
+
+export interface Identity extends Fn {
+  return: this["arg0"];
+}

tests/arrays.test.ts

@@ -0,0 +1,79 @@
+import { describe, expect, test } from "bun:test";
+import { initCorrettore, min, string, arrays, Infer } from "../src";
+import { Equal, Expect } from "./helpers.types";
+
+describe("arrays", () => {
+  const c = initCorrettore([
+    arrays.array,
+    string,
+    min,
+    arrays.nonEmpty,
+    arrays.min,
+    arrays.max,
+    arrays.length,
+  ]);
+
+  test("arrays", () => {
+    expect(() => c.array(c.string().min(2)).parse(["ab", "ba"])).not.toThrow();
+    expect(() => c.array(c.string()).parse([])).not.toThrow();
+    expect(() => c.array(c.string()).parse([42])).toThrow();
+    expect(() =>
+      c.array(c.string()).nonEmpty().parse(["a", "b"]),
+    ).not.toThrow();
+    expect(() => c.array(c.string()).nonEmpty().parse([])).toThrow();
+    expect(() =>
+      c
+        .array(c.string())
+        .nonEmpty()
+        .min(3)
+        .max(5)
+        .length(4)
+        .parse(["a", "b", "c", "d"]),
+    ).not.toThrow();
+    expect(() =>
+      c
+        .array(c.string())
+        .nonEmpty()
+        .min(3)
+        .max(5)
+        .length(4)
+        .parse(["a", "b", "d"]),
+    ).toThrow();
+
+    const schema = c.array(c.string());
+    type SchemaType = Infer<typeof schema>;
+    type _test = Expect<Equal<SchemaType, string[]>>;
+  });
+
+  test("arrays alternative syntax", () => {
+    expect(() => c.string().min(2).array().parse(["ab", "ba"])).not.toThrow();
+    expect(() => c.string().array().parse([])).not.toThrow();
+    expect(() => c.string().array().parse([42])).toThrow();
+    expect(() => c.string().array().nonEmpty().parse(["a", "b"])).not.toThrow();
+    expect(() => c.string().array().nonEmpty().parse([])).toThrow();
+    expect(() =>
+      c
+        .string()
+        .array()
+        .nonEmpty()
+        .min(3)
+        .max(5)
+        .length(4)
+        .parse(["a", "b", "c", "d"]),
+    ).not.toThrow();
+    expect(() =>
+      c
+        .string()
+        .array()
+        .nonEmpty()
+        .min(3)
+        .max(5)
+        .length(4)
+        .parse(["a", "b", "d"]),
+    ).toThrow();
+
+    const schema = c.string().array();
+    type SchemaType = Infer<typeof schema>;
+    type _test = Expect<Equal<SchemaType, string[]>>;
+  });
+});

tests/index.test.ts

@@ -56,6 +56,8 @@ describe("basic tests", () => {
     coerce.bigintCoerce,
   ]);
 
+  // TODO: split into *.test.ts files and add more tests
+
   test("smoke tests", () => {
     expect(() => c.number().parse(42)).not.toThrow();
     expect(() => c.number().parse("hello")).toThrow();
@@ -115,70 +117,6 @@ describe("basic tests", () => {
     type _typeTest3 = Expect<Equal<InferredSchema3, [string, ...string[]]>>;
   });
 
-  test("arrays", () => {
-    expect(() => c.array(c.string().min(2)).parse(["ab", "ba"])).not.toThrow();
-    expect(() => c.array(c.string()).parse([])).not.toThrow();
-    expect(() => c.array(c.string()).parse([42])).toThrow();
-    expect(() =>
-      c.array(c.string()).nonEmpty().parse(["a", "b"]),
-    ).not.toThrow();
-    expect(() => c.array(c.string()).nonEmpty().parse([])).toThrow();
-    expect(() =>
-      c
-        .array(c.string())
-        .nonEmpty()
-        .min(3)
-        .max(5)
-        .length(4)
-        .parse(["a", "b", "c", "d"]),
-    ).not.toThrow();
-    expect(() =>
-      c
-        .array(c.string())
-        .nonEmpty()
-        .min(3)
-        .max(5)
-        .length(4)
-        .parse(["a", "b", "d"]),
-    ).toThrow();
-
-    const schema = c.array(c.string());
-    type SchemaType = Infer<typeof schema>;
-    type _test = Expect<Equal<SchemaType, string[]>>;
-  });
-
-  test("arrays alternative syntax", () => {
-    expect(() => c.string().min(2).array().parse(["ab", "ba"])).not.toThrow();
-    expect(() => c.string().array().parse([])).not.toThrow();
-    expect(() => c.string().array().parse([42])).toThrow();
-    expect(() => c.string().array().nonEmpty().parse(["a", "b"])).not.toThrow();
-    expect(() => c.string().array().nonEmpty().parse([])).toThrow();
-    expect(() =>
-      c
-        .string()
-        .array()
-        .nonEmpty()
-        .min(3)
-        .max(5)
-        .length(4)
-        .parse(["a", "b", "c", "d"]),
-    ).not.toThrow();
-    expect(() =>
-      c
-        .string()
-        .array()
-        .nonEmpty()
-        .min(3)
-        .max(5)
-        .length(4)
-        .parse(["a", "b", "d"]),
-    ).toThrow();
-
-    const schema = c.string().array();
-    type SchemaType = Infer<typeof schema>;
-    type _test = Expect<Equal<SchemaType, string[]>>;
-  });
-
   test("sets", () => {
     expect(() =>
       c.set(c.string().min(2)).parse(new Set(["ab", "ba"])),