@kozojs/testing 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,79 @@
+import { Services, Kozo, KozoConfig } from '@kozojs/core';
+
+interface InjectOptions {
+    method?: string;
+    url: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    /** Shorthand: appended as query string to the URL */
+    query?: Record<string, string>;
+}
+interface TestResponse {
+    status: number;
+    headers: Headers;
+    body: string;
+    ok: boolean;
+    /** Parse the response body as JSON */
+    json<T = unknown>(): T;
+}
+interface TestClient<TServices extends Services = Services> {
+    /** The underlying Kozo app instance */
+    app: Kozo<TServices>;
+    /** Make an arbitrary in-process HTTP request */
+    inject(options: InjectOptions): Promise<TestResponse>;
+    /** GET shorthand */
+    get(url: string, opts?: Omit<InjectOptions, 'method' | 'url'>): Promise<TestResponse>;
+    /** POST shorthand — body is JSON-serialized automatically */
+    post(url: string, body?: unknown, opts?: Omit<InjectOptions, 'method' | 'url' | 'body'>): Promise<TestResponse>;
+    /** PUT shorthand */
+    put(url: string, body?: unknown, opts?: Omit<InjectOptions, 'method' | 'url' | 'body'>): Promise<TestResponse>;
+    /** PATCH shorthand */
+    patch(url: string, body?: unknown, opts?: Omit<InjectOptions, 'method' | 'url' | 'body'>): Promise<TestResponse>;
+    /** DELETE shorthand */
+    delete(url: string, opts?: Omit<InjectOptions, 'method' | 'url'>): Promise<TestResponse>;
+}
+/**
+ * Wrap an existing Kozo app with a test client.
+ *
+ * @example
+ * ```ts
+ * import { createKozo, z } from '@kozojs/core';
+ * import { createTestClient } from '@kozojs/testing';
+ *
+ * const app = createKozo();
+ * app.get('/ping', {}, () => ({ pong: true }));
+ *
+ * const client = createTestClient(app);
+ * const res = await client.get('/ping');
+ * expect(res.status).toBe(200);
+ * expect(res.json()).toEqual({ pong: true });
+ * ```
+ */
+declare function createTestClient<TServices extends Services = Services>(app: Kozo<TServices>): TestClient<TServices>;
+/**
+ * Create a Kozo app + test client in one call.
+ *
+ * @example
+ * ```ts
+ * import { z } from '@kozojs/core';
+ * import { createTestApp } from '@kozojs/testing';
+ *
+ * const { app, post } = createTestApp();
+ *
+ * app.post('/users', {
+ *   body: z.object({ name: z.string(), email: z.string().email() }),
+ * }, ({ body }) => ({ id: 1, ...body }));
+ *
+ * const res = await post('/users', { name: 'Alice', email: 'alice@example.com' });
+ * expect(res.status).toBe(200);
+ * expect(res.json()).toMatchObject({ name: 'Alice' });
+ *
+ * // Validation error
+ * const bad = await post('/users', { name: 'Alice', email: 'not-an-email' });
+ * expect(bad.status).toBe(400);
+ * expect(bad.json().errors[0]).toMatchObject({ field: 'email', code: 'invalid_string' });
+ * ```
+ */
+declare function createTestApp<TServices extends Services = Services>(config?: KozoConfig<TServices>): TestClient<TServices>;
+
+export { type InjectOptions, type TestClient, type TestResponse, createTestApp, createTestClient };

package/lib/index.js

@@ -0,0 +1,52 @@
+// src/index.ts
+import { createKozo } from "@kozojs/core";
+function buildRequest(options) {
+  const { method = "GET", url, headers = {}, body, query } = options;
+  let fullUrl = url.startsWith("http") ? url : `http://localhost${url}`;
+  if (query && Object.keys(query).length > 0) {
+    const qs = new URLSearchParams(query);
+    fullUrl += (fullUrl.includes("?") ? "&" : "?") + qs.toString();
+  }
+  const finalHeaders = { ...headers };
+  let finalBody;
+  if (body !== void 0) {
+    if (!finalHeaders["content-type"] && !finalHeaders["Content-Type"]) {
+      finalHeaders["Content-Type"] = "application/json";
+    }
+    finalBody = typeof body === "string" ? body : JSON.stringify(body);
+  }
+  return new Request(fullUrl, { method, headers: finalHeaders, body: finalBody });
+}
+async function doInject(fetchFn, options) {
+  const req = buildRequest(options);
+  const res = await Promise.resolve(fetchFn(req));
+  const bodyText = await res.text();
+  return {
+    status: res.status,
+    headers: res.headers,
+    body: bodyText,
+    ok: res.ok,
+    json() {
+      return JSON.parse(bodyText);
+    }
+  };
+}
+function createTestClient(app) {
+  const fetchFn = app.fetch.bind(app);
+  return {
+    app,
+    inject: (opts) => doInject(fetchFn, opts),
+    get: (url, opts = {}) => doInject(fetchFn, { ...opts, method: "GET", url }),
+    post: (url, body, opts = {}) => doInject(fetchFn, { ...opts, method: "POST", url, body }),
+    put: (url, body, opts = {}) => doInject(fetchFn, { ...opts, method: "PUT", url, body }),
+    patch: (url, body, opts = {}) => doInject(fetchFn, { ...opts, method: "PATCH", url, body }),
+    delete: (url, opts = {}) => doInject(fetchFn, { ...opts, method: "DELETE", url })
+  };
+}
+function createTestApp(config) {
+  return createTestClient(createKozo(config));
+}
+export {
+  createTestApp,
+  createTestClient
+};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@kozojs/testing",
+  "version": "0.1.0",
+  "description": "In-process test client for Kozo Framework — no HTTP server required",
+  "type": "module",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "files": [
+    "lib",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "import": "./lib/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [
+    "kozo",
+    "testing",
+    "test",
+    "inject",
+    "supertest",
+    "http",
+    "typescript"
+  ],
+  "author": "Kozo Team",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "peerDependencies": {
+    "@kozojs/core": ">=0.3.10"
+  },
+  "devDependencies": {
+    "@kozojs/core": "workspace:*",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.6.0",
+    "vitest": "^2.1.0"
+  }
+}