@shetty4l/core 0.1.3

package/test/http.test.ts

@@ -0,0 +1,152 @@
+import { afterAll, describe, expect, test } from "bun:test";
+import {
+  corsHeaders,
+  corsPreflightResponse,
+  createServer,
+  healthResponse,
+  jsonError,
+  jsonOk,
+} from "../src/http";
+
+// --- corsHeaders ---
+
+describe("corsHeaders", () => {
+  test("returns CORS headers", () => {
+    const headers = corsHeaders();
+    expect(headers["Access-Control-Allow-Origin"]).toBe("*");
+    expect(headers["Access-Control-Allow-Methods"]).toContain("GET");
+    expect(headers["Access-Control-Allow-Headers"]).toContain("Content-Type");
+  });
+
+  test("returns a fresh copy each time", () => {
+    const a = corsHeaders();
+    const b = corsHeaders();
+    expect(a).toEqual(b);
+    a["X-Custom"] = "mutated";
+    expect(b["X-Custom"]).toBeUndefined();
+  });
+});
+
+// --- corsPreflightResponse ---
+
+describe("corsPreflightResponse", () => {
+  test("returns 204 with CORS headers", () => {
+    const res = corsPreflightResponse();
+    expect(res.status).toBe(204);
+    expect(res.headers.get("Access-Control-Allow-Origin")).toBe("*");
+  });
+});
+
+// --- jsonOk ---
+
+describe("jsonOk", () => {
+  test("returns JSON with 200 by default", async () => {
+    const res = jsonOk({ message: "hello" });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ message: "hello" });
+  });
+
+  test("supports custom status code", () => {
+    const res = jsonOk({ id: 1 }, 201);
+    expect(res.status).toBe(201);
+  });
+
+  test("includes CORS headers", () => {
+    const res = jsonOk({});
+    expect(res.headers.get("Access-Control-Allow-Origin")).toBe("*");
+  });
+});
+
+// --- jsonError ---
+
+describe("jsonError", () => {
+  test("returns error JSON", async () => {
+    const res = jsonError(400, "bad request");
+    expect(res.status).toBe(400);
+    const body = await res.json();
+    expect(body).toEqual({ error: "bad request" });
+  });
+
+  test("includes CORS headers", () => {
+    const res = jsonError(500, "oops");
+    expect(res.headers.get("Access-Control-Allow-Origin")).toBe("*");
+  });
+});
+
+// --- healthResponse ---
+
+describe("healthResponse", () => {
+  test("returns standard health fields", async () => {
+    const startTime = Date.now() - 5000;
+    const res = healthResponse("1.0.0", startTime);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.status).toBe("healthy");
+    expect(body.version).toBe("1.0.0");
+    expect(typeof body.uptime).toBe("number");
+    expect((body.uptime as number) >= 4).toBe(true);
+  });
+
+  test("includes extra fields when provided", async () => {
+    const res = healthResponse("1.0.0", Date.now(), {
+      memories: 42,
+    });
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.memories).toBe(42);
+  });
+});
+
+// --- createServer ---
+
+describe("createServer", () => {
+  let server: ReturnType<typeof createServer> | null = null;
+
+  afterAll(() => {
+    if (server) server.stop();
+  });
+
+  test("starts server and responds to /health", async () => {
+    server = createServer({
+      port: 0, // random available port
+      version: "0.1.0-test",
+      onRequest: () => null,
+    });
+
+    const res = await fetch(`http://localhost:${server.port}/health`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.status).toBe("healthy");
+    expect(body.version).toBe("0.1.0-test");
+  });
+
+  test("handles OPTIONS preflight", async () => {
+    const res = await fetch(`http://localhost:${server!.port}/anything`, {
+      method: "OPTIONS",
+    });
+    expect(res.status).toBe(204);
+    expect(res.headers.get("Access-Control-Allow-Origin")).toBe("*");
+  });
+
+  test("routes to onRequest for custom paths", async () => {
+    server!.stop();
+    server = createServer({
+      port: 0,
+      version: "0.1.0-test",
+      onRequest: (_req, url) => {
+        if (url.pathname === "/echo") return jsonOk({ path: "/echo" });
+        return null;
+      },
+    });
+
+    const res = await fetch(`http://localhost:${server.port}/echo`);
+    expect(res.status).toBe(200);
+    const body = (await res.json()) as Record<string, unknown>;
+    expect(body.path).toBe("/echo");
+  });
+
+  test("returns 404 when onRequest returns null", async () => {
+    const res = await fetch(`http://localhost:${server!.port}/nonexistent`);
+    expect(res.status).toBe(404);
+  });
+});

package/test/result.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from "bun:test";
+import { err, ok } from "../src/result";
+
+describe("ok", () => {
+  test("creates Ok result", () => {
+    const result = ok(42);
+    expect(result.ok).toBe(true);
+    expect(result.value).toBe(42);
+  });
+
+  test("works with string values", () => {
+    const result = ok("hello");
+    expect(result.ok).toBe(true);
+    expect(result.value).toBe("hello");
+  });
+
+  test("works with objects", () => {
+    const result = ok({ name: "test" });
+    expect(result.ok).toBe(true);
+    expect(result.value).toEqual({ name: "test" });
+  });
+});
+
+describe("err", () => {
+  test("creates Err result", () => {
+    const result = err("something went wrong");
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe("something went wrong");
+  });
+
+  test("works with structured errors", () => {
+    const result = err({ code: "NOT_FOUND", message: "missing" });
+    expect(result.ok).toBe(false);
+    expect(result.error).toEqual({ code: "NOT_FOUND", message: "missing" });
+  });
+});
+
+describe("type narrowing", () => {
+  test("narrows Ok in conditional", () => {
+    const result = ok(42);
+    if (result.ok) {
+      // TypeScript knows this is Ok<number>
+      expect(result.value).toBe(42);
+    } else {
+      throw new Error("should not reach");
+    }
+  });
+
+  test("narrows Err in conditional", () => {
+    const result = err("bad");
+    if (!result.ok) {
+      // TypeScript knows this is Err<string>
+      expect(result.error).toBe("bad");
+    } else {
+      throw new Error("should not reach");
+    }
+  });
+});

package/test/signals.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, test } from "bun:test";
+import { onShutdown } from "../src/signals";
+
+describe("onShutdown", () => {
+  test("registers handler without throwing", () => {
+    // onShutdown registers process listeners — verify it doesn't throw.
+    // We can't easily test signal delivery in unit tests, but we can
+    // verify the function accepts valid inputs.
+    expect(() => {
+      onShutdown(() => {}, { signals: [] });
+    }).not.toThrow();
+  });
+
+  test("accepts async cleanup function", () => {
+    expect(() => {
+      onShutdown(async () => {}, { signals: [] });
+    }).not.toThrow();
+  });
+
+  test("accepts custom signals list", () => {
+    expect(() => {
+      onShutdown(() => {}, { signals: ["SIGUSR1"], timeoutMs: 1000 });
+    }).not.toThrow();
+  });
+});

package/test/version.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { readVersion } from "../src/version";
+
+const TMP = join(import.meta.dir, ".tmp-version");
+
+function setup() {
+  if (existsSync(TMP)) rmSync(TMP, { recursive: true });
+  mkdirSync(TMP, { recursive: true });
+}
+
+function teardown() {
+  if (existsSync(TMP)) rmSync(TMP, { recursive: true });
+}
+
+describe("readVersion", () => {
+  test("returns fallback when VERSION file missing", () => {
+    setup();
+    try {
+      expect(readVersion(TMP)).toBe("0.0.0-dev");
+    } finally {
+      teardown();
+    }
+  });
+
+  test("returns custom fallback when VERSION file missing", () => {
+    setup();
+    try {
+      expect(readVersion(TMP, "1.0.0-local")).toBe("1.0.0-local");
+    } finally {
+      teardown();
+    }
+  });
+
+  test("reads VERSION file when present", () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, "VERSION"), "2.3.4\n");
+      expect(readVersion(TMP)).toBe("2.3.4");
+    } finally {
+      teardown();
+    }
+  });
+
+  test("trims whitespace from VERSION file", () => {
+    setup();
+    try {
+      writeFileSync(join(TMP, "VERSION"), "  1.0.0  \n\n");
+      expect(readVersion(TMP)).toBe("1.0.0");
+    } finally {
+      teardown();
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "types": ["bun"]
+  },
+  "include": ["src/**/*", "test/**/*"],
+  "exclude": ["node_modules"]
+}