@vertz/testing 0.2.26 → 0.2.29

package/dist/index.d.ts

@@ -131,5 +131,77 @@ declare function createTestApp(config?: TestAppConfig): TestApp;
 * @returns A typed test app instance.
 */
 declare function createTestApp<TRouteMap extends RouteMapEntry>(config?: TestAppConfig): TestAppWithRoutes<TRouteMap>;
+import { AppBuilder } from "@vertz/server";
+import { ModelDef } from "@vertz/db";
+import { EntityDefinition, ListResult, ServiceActionDef, ServiceDefinition } from "@vertz/server";
+import { ListResult as ListResult2 } from "@vertz/server";
+interface ErrorBody {
+	error: string;
+	message: string;
+	statusCode: number;
+	details?: unknown;
+}
+type TestResponse2<T = unknown> = {
+	ok: true;
+	status: number;
+	body: T;
+	headers: Record<string, string>;
+	raw: Response;
+} | {
+	ok: false;
+	status: number;
+	body: ErrorBody;
+	headers: Record<string, string>;
+	raw: Response;
+};
+interface RequestOptions2<TBody = unknown> {
+	body?: TBody;
+	headers?: Record<string, string>;
+}
+interface EntityListOptions {
+	where?: Record<string, unknown>;
+	orderBy?: Record<string, "asc" | "desc">;
+	limit?: number;
+	after?: string;
+	select?: Record<string, true>;
+	include?: Record<string, unknown>;
+	headers?: Record<string, string>;
+}
+interface EntityRequestOptions {
+	headers?: Record<string, string>;
+}
+interface ServiceCallOptions {
+	headers?: Record<string, string>;
+}
+interface TestClientOptions {
+	defaultHeaders?: Record<string, string>;
+}
+interface EntityTestProxy<TModel extends ModelDef> {
+	list(options?: EntityListOptions): Promise<TestResponse2<ListResult<TModel["table"]["$response"]>>>;
+	get(id: string, options?: EntityRequestOptions): Promise<TestResponse2<TModel["table"]["$response"]>>;
+	create(body: TModel["table"]["$create_input"], options?: EntityRequestOptions): Promise<TestResponse2<TModel["table"]["$response"]>>;
+	update(id: string, body: TModel["table"]["$update_input"], options?: EntityRequestOptions): Promise<TestResponse2<TModel["table"]["$response"]>>;
+	delete(id: string, options?: EntityRequestOptions): Promise<TestResponse2<null>>;
+}
+/** Extract TActions from a ServiceDefinition's phantom type field */
+type InferActions<TDef> = TDef extends {
+	readonly __actions?: infer A;
+} ? A extends Record<string, ServiceActionDef<infer _I, infer _O, infer _C>> ? A : Record<string, ServiceActionDef> : Record<string, ServiceActionDef>;
+type ExtractInput<T> = T extends ServiceActionDef<infer TInput, infer _O, infer _C> ? TInput : unknown;
+type ExtractOutput<T> = T extends ServiceActionDef<infer _I, infer TOutput, infer _C> ? TOutput : unknown;
+type ServiceTestProxy<TDef extends ServiceDefinition> = { [K in Extract<keyof InferActions<TDef>, string>] : [unknown] extends [ExtractInput<InferActions<TDef>[K]>] ? (options?: ServiceCallOptions) => Promise<TestResponse2<ExtractOutput<InferActions<TDef>[K]>>> : (body: ExtractInput<InferActions<TDef>[K]>, options?: ServiceCallOptions) => Promise<TestResponse2<ExtractOutput<InferActions<TDef>[K]>>> };
+interface TestClient {
+	entity<TModel extends ModelDef>(def: EntityDefinition<TModel>): EntityTestProxy<TModel>;
+	service<TDef extends ServiceDefinition>(def: TDef): ServiceTestProxy<TDef>;
+	/** Returns a new immutable client with merged default headers. */
+	withHeaders(headers: Record<string, string>): TestClient;
+	get(path: string, options?: RequestOptions2): Promise<TestResponse2>;
+	post(path: string, options?: RequestOptions2): Promise<TestResponse2>;
+	put(path: string, options?: RequestOptions2): Promise<TestResponse2>;
+	patch(path: string, options?: RequestOptions2): Promise<TestResponse2>;
+	delete(path: string, options?: RequestOptions2): Promise<TestResponse2>;
+	head(path: string, options?: RequestOptions2): Promise<TestResponse2>;
+}
+declare function createTestClient(server: AppBuilder, options?: TestClientOptions): TestClient;
 type DeepPartial<T> = { [P in keyof T]? : T[P] extends object ? DeepPartial<T[P]> : T[P] };
-export { createTestApp, TestRouteEntry, TestResponse, TestRequestBuilder, TestAppConfig, TestApp, RouteMapEntry, RequestOptions, DeepPartial };
+export { createTestClient, createTestApp, TestResponse2 as TypedTestResponse, TestRouteEntry, TestResponse, TestRequestBuilder, TestClientOptions, TestClient, TestAppConfig, TestApp, ServiceTestProxy, ServiceCallOptions, RouteMapEntry, RequestOptions, ListResult2 as ListResult, ErrorBody, EntityTestProxy, EntityRequestOptions, EntityListOptions, DeepPartial };

package/dist/index.js

@@ -157,6 +157,180 @@ class ResponseValidationError extends Error {
     this.name = "ResponseValidationError";
   }
 }
+// src/test-client.ts
+function resolveEntityBasePath(server, entityName) {
+  const routes = server.router.routes;
+  const suffix = `/${entityName}`;
+  const listRoute = routes.find((r) => r.method === "GET" && (r.path === suffix || r.path.endsWith(suffix)));
+  if (listRoute)
+    return listRoute.path;
+  return `/api/${entityName}`;
+}
+function resolveServiceBasePath(server, serviceName) {
+  const routes = server.router.routes;
+  const segmentPattern = new RegExp(`/${serviceName}/`);
+  const serviceRoute = routes.find((r) => r.method === "POST" && segmentPattern.test(r.path));
+  if (serviceRoute) {
+    const idx = serviceRoute.path.indexOf(`/${serviceName}/`);
+    return serviceRoute.path.slice(0, idx + 1 + serviceName.length);
+  }
+  return `/api/${serviceName}`;
+}
+async function parseResponse(raw) {
+  const status = raw.status;
+  const ok = raw.ok;
+  const headers = {};
+  raw.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  let body;
+  const contentType = raw.headers.get("content-type");
+  if (contentType?.includes("application/json")) {
+    body = await raw.json();
+  } else if (status === 204 || raw.headers.get("content-length") === "0") {
+    body = null;
+  } else {
+    try {
+      body = await raw.json();
+    } catch {
+      body = null;
+    }
+  }
+  return { ok, status, body, headers, raw };
+}
+function getRequestHandler(server) {
+  if ("requestHandler" in server && typeof server.requestHandler === "function") {
+    return server.requestHandler;
+  }
+  return server.handler;
+}
+async function dispatch(handler, method, path, defaultHeaders, options) {
+  const mergedHeaders = { ...defaultHeaders, ...options?.headers };
+  if (options?.body !== undefined) {
+    mergedHeaders["content-type"] = "application/json";
+  }
+  const request = new Request(`http://localhost${path}`, {
+    method,
+    body: options?.body !== undefined ? JSON.stringify(options.body) : undefined,
+    headers: mergedHeaders
+  });
+  const raw = await handler(request);
+  return parseResponse(raw);
+}
+function createEntityProxy(handler, basePath, defaultHeaders) {
+  return {
+    list(options) {
+      const params = new URLSearchParams;
+      if (options?.where)
+        params.set("where", JSON.stringify(options.where));
+      if (options?.orderBy)
+        params.set("orderBy", JSON.stringify(options.orderBy));
+      if (options?.limit !== undefined)
+        params.set("limit", String(options.limit));
+      if (options?.after)
+        params.set("after", options.after);
+      if (options?.select)
+        params.set("select", JSON.stringify(options.select));
+      if (options?.include)
+        params.set("include", JSON.stringify(options.include));
+      const qs = params.toString();
+      const path = qs ? `${basePath}?${qs}` : basePath;
+      return dispatch(handler, "GET", path, { ...defaultHeaders, ...options?.headers });
+    },
+    get(id, options) {
+      return dispatch(handler, "GET", `${basePath}/${id}`, {
+        ...defaultHeaders,
+        ...options?.headers
+      });
+    },
+    create(body, options) {
+      return dispatch(handler, "POST", basePath, { ...defaultHeaders, ...options?.headers }, {
+        body
+      });
+    },
+    update(id, body, options) {
+      return dispatch(handler, "PATCH", `${basePath}/${id}`, {
+        ...defaultHeaders,
+        ...options?.headers
+      }, { body });
+    },
+    delete(id, options) {
+      return dispatch(handler, "DELETE", `${basePath}/${id}`, {
+        ...defaultHeaders,
+        ...options?.headers
+      });
+    }
+  };
+}
+function createServiceProxy(handler, basePath, serviceDef, defaultHeaders) {
+  const actionNames = Object.keys(serviceDef.actions);
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (typeof prop !== "string")
+        return;
+      if (!actionNames.includes(prop))
+        return;
+      return (...args) => {
+        const action = serviceDef.actions[prop];
+        const hasBody = action?.body !== undefined;
+        let body;
+        let options;
+        if (hasBody) {
+          body = args[0];
+          options = args[1];
+        } else {
+          options = args[0];
+        }
+        const method = action?.method?.toUpperCase() ?? "POST";
+        const actionPath = action?.path ?? `/${prop}`;
+        const fullPath = `${basePath}${actionPath}`;
+        return dispatch(handler, method, fullPath, {
+          ...defaultHeaders,
+          ...options?.headers
+        }, body !== undefined ? { body } : undefined);
+      };
+    }
+  });
+}
+function createTestClient(server, options) {
+  const defaultHeaders = options?.defaultHeaders ?? {};
+  const handler = getRequestHandler(server);
+  function makeClient(headers) {
+    return {
+      entity(def) {
+        const basePath = resolveEntityBasePath(server, def.name);
+        return createEntityProxy(handler, basePath, headers);
+      },
+      service(def) {
+        const basePath = resolveServiceBasePath(server, def.name);
+        return createServiceProxy(handler, basePath, def, headers);
+      },
+      withHeaders(newHeaders) {
+        return makeClient({ ...headers, ...newHeaders });
+      },
+      get(path, opts) {
+        return dispatch(handler, "GET", path, headers, opts);
+      },
+      post(path, opts) {
+        return dispatch(handler, "POST", path, headers, opts);
+      },
+      put(path, opts) {
+        return dispatch(handler, "PUT", path, headers, opts);
+      },
+      patch(path, opts) {
+        return dispatch(handler, "PATCH", path, headers, opts);
+      },
+      delete(path, opts) {
+        return dispatch(handler, "DELETE", path, headers, opts);
+      },
+      head(path, opts) {
+        return dispatch(handler, "HEAD", path, headers, opts);
+      }
+    };
+  }
+  return makeClient(defaultHeaders);
+}
 export {
+  createTestClient,
   createTestApp
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/testing",
-  "version": "0.2.26",
+  "version": "0.2.29",
   "type": "module",
   "license": "MIT",
   "description": "Testing utilities for Vertz applications",
@@ -30,12 +30,13 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@vertz/core": "^0.2.25",
-    "@vertz/server": "^0.2.25"
+    "@vertz/core": "^0.2.28",
+    "@vertz/db": "^0.2.28",
+    "@vertz/server": "^0.2.28"
   },
   "devDependencies": {
     "@types/node": "^25.3.1",
-    "@vertz/schema": "^0.2.25",
+    "@vertz/schema": "^0.2.28",
     "bunup": "^0.16.31",
     "typescript": "^5.7.0"
   },