@wp-typia/rest 0.3.4 → 0.3.6

package/README.md

@@ -37,6 +37,11 @@ const endpoint = createEndpoint<MyRequest, MyResponse>({
 const result = await callEndpoint(endpoint, { title: "Hello" });
 ```
 
+`callEndpoint(...)` returns `EndpointValidationResult<Req, Res>`. If request
+validation fails before transport execution, the result keeps
+`validationTarget: "request"`. Response validation runs after transport and uses
+`validationTarget: "response"`.
+
 If you need a canonical REST URL for a route path, use:
 
 ```ts

package/dist/client.d.ts

@@ -1,7 +1,9 @@
 import type { APIFetchOptions, ApiFetch } from "@wordpress/api-fetch";
+import type { EndpointValidationResult } from "@wp-typia/api-client";
 import { type ValidationLike, type ValidationResult } from "./internal/runtime-primitives.js";
 export type { ValidationError, ValidationLike, ValidationResult } from "./internal/runtime-primitives.js";
 export { isValidationResult, normalizeValidationError, toValidationResult } from "./internal/runtime-primitives.js";
+export type { EndpointRequestValidationResult, EndpointResponseValidationResult, EndpointValidationResult, EndpointValidationTarget, } from "@wp-typia/api-client";
 export interface ValidatedFetch<T> {
     assertFetch(options: APIFetchOptions): Promise<T>;
     fetch(options: APIFetchOptions): Promise<ValidationResult<T>>;
@@ -25,4 +27,4 @@ export interface EndpointCallOptions {
 export declare function resolveRestRouteUrl(routePath: string, root?: string): string;
 export declare function createValidatedFetch<T>(validator: (input: unknown) => ValidationLike<T>, fetchFn?: ApiFetch): ValidatedFetch<T>;
 export declare function createEndpoint<Req, Res>(config: ApiEndpoint<Req, Res>): ApiEndpoint<Req, Res>;
-export declare function callEndpoint<Req, Res>(endpoint: ApiEndpoint<Req, Res>, request: Req, { fetchFn, requestOptions }?: EndpointCallOptions): Promise<ValidationResult<Res>>;
+export declare function callEndpoint<Req, Res>(endpoint: ApiEndpoint<Req, Res>, request: Req, { fetchFn, requestOptions }?: EndpointCallOptions): Promise<EndpointValidationResult<Req, Res>>;

package/dist/client.js

@@ -1,4 +1,5 @@
-import { isFormDataLike, isPlainObject, toValidationResult, } from "./internal/runtime-primitives.js";
+import { encodeGetLikeRequest, joinPathWithQuery, joinUrlWithQuery, mergeHeaderInputs, parseResponsePayload, } from "@wp-typia/api-client/client-utils";
+import { isFormDataLike, toValidationResult, } from "./internal/runtime-primitives.js";
 export { isValidationResult, normalizeValidationError, toValidationResult } from "./internal/runtime-primitives.js";
 function getDefaultRestRoot() {
     if (typeof window !== "undefined") {
@@ -75,73 +76,6 @@ async function defaultFetch(options) {
         return text;
     }
 }
-async function parseResponsePayload(response) {
-    if (response.status === 204) {
-        return undefined;
-    }
-    const text = await response.text();
-    if (!text) {
-        return undefined;
-    }
-    try {
-        return JSON.parse(text);
-    }
-    catch {
-        return text;
-    }
-}
-function encodeGetLikeRequest(request) {
-    if (request === undefined || request === null) {
-        return "";
-    }
-    if (request instanceof URLSearchParams) {
-        return request.toString();
-    }
-    if (!isPlainObject(request)) {
-        throw new Error("GET/DELETE endpoint requests must be plain objects or URLSearchParams.");
-    }
-    const params = new URLSearchParams();
-    for (const [key, value] of Object.entries(request)) {
-        if (value === undefined || value === null) {
-            continue;
-        }
-        if (Array.isArray(value)) {
-            for (const item of value) {
-                params.append(key, String(item));
-            }
-            continue;
-        }
-        params.set(key, String(value));
-    }
-    return params.toString();
-}
-function joinPathWithQuery(path, query) {
-    if (!query) {
-        return path;
-    }
-    return path.includes("?") ? `${path}&${query}` : `${path}?${query}`;
-}
-function joinUrlWithQuery(url, query) {
-    if (!query) {
-        return url;
-    }
-    const nextUrl = new URL(url, typeof window !== "undefined" ? window.location.origin : "http://localhost");
-    for (const [key, value] of new URLSearchParams(query)) {
-        nextUrl.searchParams.append(key, value);
-    }
-    return nextUrl.toString();
-}
-function mergeHeaderInputs(baseHeaders, requestHeaders) {
-    if (!baseHeaders && !requestHeaders) {
-        return undefined;
-    }
-    const mergedHeaders = new Headers(baseHeaders);
-    const nextHeaders = new Headers(requestHeaders);
-    for (const [key, value] of nextHeaders.entries()) {
-        mergedHeaders.set(key, value);
-    }
-    return Object.fromEntries(mergedHeaders.entries());
-}
 function buildEndpointFetchOptions(endpoint, request) {
     const baseOptions = endpoint.buildRequestOptions?.(request) ?? {};
     if (endpoint.method === "GET" || endpoint.method === "DELETE") {
@@ -235,11 +169,26 @@ export function createValidatedFetch(validator, fetchFn = defaultFetch) {
 export function createEndpoint(config) {
     return config;
 }
+function isInvalidValidationResult(validation) {
+    return validation.isValid === false;
+}
+function toEndpointRequestValidationResult(validation) {
+    return {
+        ...validation,
+        validationTarget: "request",
+    };
+}
+function toEndpointResponseValidationResult(validation) {
+    return {
+        ...validation,
+        validationTarget: "response",
+    };
+}
 export async function callEndpoint(endpoint, request, { fetchFn = defaultFetch, requestOptions } = {}) {
     const requestValidation = endpoint.validateRequest(request);
-    if (!requestValidation.isValid) {
-        return requestValidation;
+    if (isInvalidValidationResult(requestValidation)) {
+        return toEndpointRequestValidationResult(requestValidation);
     }
     const payload = await fetchFn(mergeFetchOptions(buildEndpointFetchOptions(endpoint, request), requestOptions));
-    return endpoint.validateResponse(payload);
+    return toEndpointResponseValidationResult(endpoint.validateResponse(payload));
 }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export { createEndpoint, createValidatedFetch, callEndpoint, isValidationResult, normalizeValidationError, resolveRestRouteUrl, toValidationResult, type ApiEndpoint, type EndpointCallOptions, type ValidatedFetch, type ValidationResult, type ValidationError, type ValidationLike, } from "./client.js";
+export { createEndpoint, createValidatedFetch, callEndpoint, isValidationResult, normalizeValidationError, resolveRestRouteUrl, toValidationResult, type ApiEndpoint, type EndpointCallOptions, type EndpointRequestValidationResult, type EndpointResponseValidationResult, type EndpointValidationResult, type EndpointValidationTarget, type ValidatedFetch, type ValidationResult, type ValidationError, type ValidationLike, } from "./client.js";
 export { createHeadersDecoder, createParameterDecoder, createQueryDecoder, } from "./http.js";

package/dist/internal/runtime-primitives.d.ts

@@ -1 +1 @@
-export { isFormDataLike, isPlainObject, isValidationResult, normalizeExpected, normalizePath, normalizeValidationError, toValidationResult, type RawValidationError, type ValidationError, type ValidationLike, type ValidationResult, } from "@wp-typia/api-client/internal/runtime-primitives";
+export { isFormDataLike, isPlainObject, isValidationResult, normalizeExpected, normalizePath, normalizeValidationError, toValidationResult, type RawValidationError, type ValidationError, type ValidationLike, type ValidationResult, } from "@wp-typia/api-client/runtime-primitives";

package/dist/internal/runtime-primitives.js

@@ -1 +1 @@
-export { isFormDataLike, isPlainObject, isValidationResult, normalizeExpected, normalizePath, normalizeValidationError, toValidationResult, } from "@wp-typia/api-client/internal/runtime-primitives";
+export { isFormDataLike, isPlainObject, isValidationResult, normalizeExpected, normalizePath, normalizeValidationError, toValidationResult, } from "@wp-typia/api-client/runtime-primitives";

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import { createElement } from "@wordpress/element";
 import type { ApiFetch } from "@wordpress/api-fetch";
-import { type ApiEndpoint, type EndpointCallOptions, type ValidationResult } from "./client.js";
+import { type ApiEndpoint, type EndpointCallOptions, type EndpointResponseValidationResult, type EndpointValidationResult } from "./client.js";
 type EndpointDataUpdater<T> = T | ((current: T | undefined) => T | undefined);
 export interface EndpointDataClient {
     invalidate<Req, Res>(endpoint: ApiEndpoint<Req, Res>, request?: Req): void;
@@ -19,31 +19,31 @@ export interface UseEndpointQueryOptions<_Req, Res, Selected = Res> {
     fetchFn?: ApiFetch;
     initialData?: Res;
     onError?: (error: unknown) => void | Promise<void>;
-    onSuccess?: (data: Selected, validation: ValidationResult<Res>) => void | Promise<void>;
+    onSuccess?: (data: Selected, validation: EndpointResponseValidationResult<Res>) => void | Promise<void>;
     resolveCallOptions?: () => EndpointCallOptions | undefined;
     select?: (data: Res) => Selected;
     staleTime?: number;
 }
-export interface UseEndpointQueryResult<Res, Selected = Res> {
+export interface UseEndpointQueryResult<Res, Selected = Res, Req = unknown> {
     data: Selected | undefined;
     error: unknown;
     isFetching: boolean;
     isLoading: boolean;
-    refetch: () => Promise<ValidationResult<Res>>;
-    validation: ValidationResult<Res> | null;
+    refetch: () => Promise<EndpointValidationResult<Req, Res>>;
+    validation: EndpointValidationResult<Req, Res> | null;
 }
 export interface UseEndpointMutationOptions<Req, Res, Context = unknown> {
     client?: EndpointDataClient;
     fetchFn?: ApiFetch;
-    invalidate?: EndpointInvalidateTargets | ((data: Res | undefined, variables: Req, validation: ValidationResult<Res>) => EndpointInvalidateTargets);
+    invalidate?: EndpointInvalidateTargets | ((data: Res | undefined, variables: Req, validation: EndpointValidationResult<Req, Res>) => EndpointInvalidateTargets);
     onError?: (error: unknown, variables: Req, client: EndpointDataClient, context: Context | undefined) => void | Promise<void>;
     onMutate?: (variables: Req, client: EndpointDataClient) => Context | Promise<Context>;
     onSettled?: (result: {
         data: Res | undefined;
         error: unknown;
-        validation: ValidationResult<Res> | null;
+        validation: EndpointValidationResult<Req, Res> | null;
     }, variables: Req, client: EndpointDataClient, context: Context | undefined) => void | Promise<void>;
-    onSuccess?: (data: Res | undefined, variables: Req, validation: ValidationResult<Res>, client: EndpointDataClient, context: Context | undefined) => void | Promise<void>;
+    onSuccess?: (data: Res | undefined, variables: Req, validation: EndpointResponseValidationResult<Res>, client: EndpointDataClient, context: Context | undefined) => void | Promise<void>;
     resolveCallOptions?: (variables: Req) => EndpointCallOptions | undefined;
 }
 export interface UseEndpointMutationResult<Req, Res> {
@@ -51,9 +51,9 @@ export interface UseEndpointMutationResult<Req, Res> {
     error: unknown;
     isPending: boolean;
     mutate: (variables: Req) => void;
-    mutateAsync: (variables: Req) => Promise<ValidationResult<Res>>;
+    mutateAsync: (variables: Req) => Promise<EndpointValidationResult<Req, Res>>;
     reset: () => void;
-    validation: ValidationResult<Res> | null;
+    validation: EndpointValidationResult<Req, Res> | null;
 }
 export interface EndpointDataProviderProps {
     children?: unknown;
@@ -62,6 +62,6 @@ export interface EndpointDataProviderProps {
 export declare function createEndpointDataClient(): EndpointDataClient;
 export declare function EndpointDataProvider({ children, client, }: EndpointDataProviderProps): ReturnType<typeof createElement>;
 export declare function useEndpointDataClient(): EndpointDataClient;
-export declare function useEndpointQuery<Req, Res, Selected = Res>(endpoint: ApiEndpoint<Req, Res>, request: Req, options?: UseEndpointQueryOptions<Req, Res, Selected>): UseEndpointQueryResult<Res, Selected>;
+export declare function useEndpointQuery<Req, Res, Selected = Res>(endpoint: ApiEndpoint<Req, Res>, request: Req, options?: UseEndpointQueryOptions<Req, Res, Selected>): UseEndpointQueryResult<Res, Selected, Req>;
 export declare function useEndpointMutation<Req, Res, Context = unknown>(endpoint: ApiEndpoint<Req, Res>, options?: UseEndpointMutationOptions<Req, Res, Context>): UseEndpointMutationResult<Req, Res>;
 export {};

package/dist/react.js

@@ -10,6 +10,18 @@ const EMPTY_SNAPSHOT = {
     validation: null,
 };
 const EndpointDataClientContext = createContext(null);
+const endpointIdentityIds = new WeakMap();
+let nextEndpointIdentityId = 0;
+function getStableEndpointIdentity(value) {
+    const existing = endpointIdentityIds.get(value);
+    if (existing !== undefined) {
+        return existing;
+    }
+    const created = nextEndpointIdentityId;
+    nextEndpointIdentityId += 1;
+    endpointIdentityIds.set(value, created);
+    return created;
+}
 function normalizeCacheValue(value) {
     if (value === undefined) {
         return undefined;
@@ -45,7 +57,18 @@ function normalizeCacheValue(value) {
     return String(value);
 }
 function createEndpointPrefix(endpoint) {
-    return `${endpoint.method} ${endpoint.path}`;
+    const requestValidatorId = getStableEndpointIdentity(endpoint.validateRequest);
+    const responseValidatorId = getStableEndpointIdentity(endpoint.validateResponse);
+    const requestBuilderId = endpoint.buildRequestOptions !== undefined
+        ? getStableEndpointIdentity(endpoint.buildRequestOptions)
+        : -1;
+    return [
+        endpoint.method,
+        endpoint.path,
+        `request:${requestValidatorId}`,
+        `response:${responseValidatorId}`,
+        `builder:${requestBuilderId}`,
+    ].join(" ");
 }
 function createCacheKey(endpoint, request) {
     const requestValidation = endpoint.validateRequest(request);
@@ -103,6 +126,21 @@ function isEntryStale(entry, staleTime) {
 function asInternalClient(client) {
     return client;
 }
+function isInvalidValidationResult(validation) {
+    return validation.isValid === false;
+}
+function toEndpointRequestValidationResult(validation) {
+    return {
+        ...validation,
+        validationTarget: "request",
+    };
+}
+function toEndpointResponseValidationResult(validation) {
+    return {
+        ...validation,
+        validationTarget: "response",
+    };
+}
 export function createEndpointDataClient() {
     const entries = new Map();
     function notify(cacheKey) {
@@ -171,11 +209,11 @@ export function createEndpointDataClient() {
             entry.data = resolvedNext;
             entry.error = null;
             entry.updatedAt = Date.now();
-            entry.validation = {
+            entry.validation = toEndpointResponseValidationResult({
                 data: resolvedNext,
                 errors: [],
                 isValid: true,
-            };
+            });
             syncSnapshot(entry);
             notify(cacheKey);
         },
@@ -194,6 +232,9 @@ export function createEndpointDataClient() {
             if (validation.isValid) {
                 entry.data = validation.data;
             }
+            else if (validation.validationTarget === "request") {
+                entry.data = undefined;
+            }
             syncSnapshot(entry);
             notify(cacheKey);
         },
@@ -257,11 +298,11 @@ export function createEndpointDataClient() {
             entry.data = data;
             entry.error = null;
             entry.updatedAt = Date.now();
-            entry.validation = {
+            entry.validation = toEndpointResponseValidationResult({
                 data,
                 errors: [],
                 isValid: true,
-            };
+            });
             syncSnapshot(entry);
             notify(cacheKey);
         },
@@ -328,8 +369,8 @@ export function useEndpointQuery(endpoint, request, options = {}) {
     if (!executeQueryRef.current) {
         executeQueryRef.current = async (force) => {
             const latest = latestRef.current;
-            if (!latest.requestValidation.isValid) {
-                const invalidValidation = latest.requestValidation;
+            if (isInvalidValidationResult(latest.requestValidation)) {
+                const invalidValidation = toEndpointRequestValidationResult(latest.requestValidation);
                 latest.client.__publishValidation(latest.cacheKey, invalidValidation);
                 return invalidValidation;
             }
@@ -371,11 +412,11 @@ export function useEndpointQuery(endpoint, request, options = {}) {
         if (!enabled) {
             return;
         }
-        if (!prepared.requestValidation.isValid) {
+        if (isInvalidValidationResult(prepared.requestValidation)) {
             if (snapshot.validation?.isValid === false) {
                 return;
             }
-            client.__publishValidation(prepared.cacheKey, prepared.requestValidation);
+            client.__publishValidation(prepared.cacheKey, toEndpointRequestValidationResult(prepared.requestValidation));
             return;
         }
         if (snapshot.isFetching) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wp-typia/rest",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "Typed WordPress REST helpers powered by Typia validation",
   "type": "module",
   "main": "dist/index.js",
@@ -59,10 +59,10 @@
   "engines": {
     "node": ">=20.0.0",
     "npm": ">=10.0.0",
-    "bun": ">=1.3.10"
+    "bun": ">=1.3.11"
   },
   "dependencies": {
-    "@wp-typia/api-client": "^0.4.0",
+    "@wp-typia/api-client": "^0.4.3",
     "@typia/interface": "^12.0.1",
     "@wordpress/api-fetch": "^7.42.0"
   },