cushin-monorepo 3.0.1

package/test-headers-runtime.mjs

@@ -0,0 +1,106 @@
+import {
+  defineEndpoint,
+  defineConfig,
+  createAPIClient,
+} from "./packages/api-runtime/dist/index.js";
+import { z } from "zod";
+
+console.log("Testing runtime header filtering...\n");
+
+// Create test endpoints
+const config = defineConfig({
+  baseUrl: "https://httpbin.org",
+  endpoints: {
+    testWithHeaders: defineEndpoint({
+      path: "headers",
+      method: "GET",
+      response: z.any(),
+      headers: {
+        "X-Custom-Header": "custom-value",
+        "X-Keep-This": "keep",
+      },
+    }),
+    testWithMixedHeaders: defineEndpoint({
+      path: "headers",
+      method: "GET",
+      response: z.any(),
+      headers: {
+        "X-Custom-Header": "custom-value",
+        "X-Remove-Undefined": undefined,
+        "X-Remove-Null": null,
+        "X-Keep-This": "keep",
+      },
+    }),
+    testWithAllRemoved: defineEndpoint({
+      path: "headers",
+      method: "GET",
+      response: z.any(),
+      headers: {
+        "X-Remove-1": undefined,
+        "X-Remove-2": null,
+      },
+    }),
+  },
+});
+
+// Create API client
+const client = createAPIClient(config);
+
+console.log("Test 1: Headers with only string values");
+try {
+  const response1 = await client.testWithHeaders();
+  console.log("✓ Request succeeded");
+  console.log("  Headers sent:", response1.headers);
+  if (
+    response1.headers["X-Custom-Header"] === "custom-value" &&
+    response1.headers["X-Keep-This"] === "keep"
+  ) {
+    console.log("  ✓ Both headers were sent correctly\n");
+  } else {
+    console.log("  ✗ Headers were not sent correctly\n");
+  }
+} catch (error) {
+  console.log("✗ Request failed:", error.message, "\n");
+}
+
+console.log("Test 2: Headers with undefined and null values");
+try {
+  const response2 = await client.testWithMixedHeaders();
+  console.log("✓ Request succeeded");
+  console.log("  Headers sent:", response2.headers);
+  if (
+    response2.headers["X-Custom-Header"] === "custom-value" &&
+    response2.headers["X-Keep-This"] === "keep" &&
+    !response2.headers["X-Remove-Undefined"] &&
+    !response2.headers["X-Remove-Null"]
+  ) {
+    console.log(
+      "  ✓ Only non-null/undefined headers were sent (undefined/null headers filtered out)\n",
+    );
+  } else {
+    console.log("  ✗ Headers were not filtered correctly\n");
+  }
+} catch (error) {
+  console.log("✗ Request failed:", error.message, "\n");
+}
+
+console.log("Test 3: All headers are undefined/null");
+try {
+  const response3 = await client.testWithAllRemoved();
+  console.log("✓ Request succeeded");
+  console.log("  Headers sent:", response3.headers);
+  if (
+    !response3.headers["X-Remove-1"] &&
+    !response3.headers["X-Remove-2"]
+  ) {
+    console.log(
+      "  ✓ All undefined/null headers were filtered out (no custom headers sent)\n",
+    );
+  } else {
+    console.log("  ✗ Headers were not filtered correctly\n");
+  }
+} catch (error) {
+  console.log("✗ Request failed:", error.message, "\n");
+}
+
+console.log("Runtime tests completed! ✨");

package/test-headers.mjs

@@ -0,0 +1,79 @@
+import { defineEndpoint, defineConfig } from "./packages/api-runtime/dist/index.js";
+import { z } from "zod";
+
+console.log("Testing header unsetting functionality...\n");
+
+// Test 1: Headers with string values
+const endpoint1 = defineEndpoint({
+  path: "/test",
+  method: "GET",
+  response: z.object({ message: z.string() }),
+  headers: {
+    "X-Custom-Header": "value1",
+    "X-Another-Header": "value2",
+  },
+});
+
+console.log("✓ Test 1: Headers with string values");
+console.log("  Input:", endpoint1.headers);
+console.log("  Expected: All headers should be set");
+console.log("");
+
+// Test 2: Headers with undefined values (should be filtered out)
+const endpoint2 = defineEndpoint({
+  path: "/test",
+  method: "GET",
+  response: z.object({ message: z.string() }),
+  headers: {
+    "X-Custom-Header": "value1",
+    "X-Remove-This": undefined,
+    "X-Another-Header": "value2",
+  },
+});
+
+console.log("✓ Test 2: Headers with undefined values");
+console.log("  Input:", endpoint2.headers);
+console.log("  Expected: X-Remove-This should be undefined");
+console.log("");
+
+// Test 3: Headers with null values (should be filtered out)
+const endpoint3 = defineEndpoint({
+  path: "/test",
+  method: "GET",
+  response: z.object({ message: z.string() }),
+  headers: {
+    "X-Custom-Header": "value1",
+    "X-Remove-This": null,
+    "X-Another-Header": "value2",
+  },
+});
+
+console.log("✓ Test 3: Headers with null values");
+console.log("  Input:", endpoint3.headers);
+console.log("  Expected: X-Remove-This should be null");
+console.log("");
+
+// Test 4: Mixed headers
+const endpoint4 = defineEndpoint({
+  path: "/test",
+  method: "POST",
+  response: z.object({ success: z.boolean() }),
+  body: z.object({ data: z.string() }),
+  headers: {
+    "X-Keep-This": "keep",
+    "X-Remove-Undefined": undefined,
+    "X-Remove-Null": null,
+    "X-Also-Keep": "also-keep",
+  },
+});
+
+console.log("✓ Test 4: Mixed headers");
+console.log("  Input:", endpoint4.headers);
+console.log("  Expected: Only X-Keep-This and X-Also-Keep should have string values");
+console.log("");
+
+console.log("All type checks passed! ✨");
+console.log("\nThe implementation allows:");
+console.log("  - Setting headers to string values");
+console.log("  - Setting headers to undefined to unset them");
+console.log("  - Setting headers to null to unset them");

package/test-internal-calls.mjs

@@ -0,0 +1,57 @@
+import { createAPIClient } from "./packages/api-runtime/dist/client.js";
+import simpleConfig from "./test-simple-config.mjs";
+
+console.log("=== TESTING INTERNAL request() CALLS ===\n");
+console.log("Analyzing what parameters are passed to this.request()\n");
+
+const client = createAPIClient(simpleConfig);
+
+// Inspect the actual generated function code
+console.log("1. listUsers (no params, no query):");
+console.log(client.listUsers.toString());
+console.log("   → Calls: this.request(endpoint)");
+console.log("   → params argument: NOT PASSED (undefined by default)\n");
+
+console.log("2. searchUsers (query only):");
+console.log(client.searchUsers.toString());
+console.log("   → Calls: this.request(endpoint, undefined, query)");
+console.log("   → params argument: EXPLICITLY undefined ⚠️\n");
+
+console.log("3. getUser (params only):");
+console.log(client.getUser.toString());
+console.log("   → Calls: this.request(endpoint, params)");
+console.log("   → params argument: passed\n");
+
+console.log("4. getUserPosts (params + query):");
+console.log(client.getUserPosts.toString());
+console.log("   → Calls: this.request(endpoint, params, query)");
+console.log("   → params argument: passed\n");
+
+console.log("5. createSession (POST, no params, no body):");
+console.log(client.createSession.toString());
+console.log("   → Calls: this.request(endpoint)");
+console.log("   → params argument: NOT PASSED (undefined by default)\n");
+
+console.log("6. createUser (POST, body only):");
+console.log(client.createUser.toString());
+console.log("   → Calls: this.request(endpoint, undefined, undefined, body)");
+console.log("   → params argument: EXPLICITLY undefined ⚠️\n");
+
+console.log("7. updateUser (POST, params + body):");
+console.log(client.updateUser.toString());
+console.log("   → Calls: this.request(endpoint, params, undefined, body)");
+console.log("   → params argument: passed\n");
+
+console.log("\n=== ANALYSIS ===\n");
+console.log("Situations where params is EXPLICITLY passed as undefined:");
+console.log("  1. GET với query only: this.request(endpoint, undefined, query)");
+console.log("  2. POST/etc với body only: this.request(endpoint, undefined, undefined, body)");
+console.log("");
+console.log("This is happening in generateMethods() at:");
+console.log("  - Line 266-269 (GET with query only)");
+console.log("  - Line 283-287 (POST with body only)");
+console.log("");
+console.log("✅ However, this.request() handles this correctly!");
+console.log("   The buildPath() method checks 'if (!params) return path;'");
+console.log("   So passing undefined explicitly is SAFE and has no issues.");
+console.log("");

package/test-ky-formdata.mjs

@@ -0,0 +1,81 @@
+/**
+ * Direct ky test to understand FormData behavior
+ */
+import ky from 'ky';
+
+console.log('\n🧪 Testing KY FormData Behavior\n');
+
+// Create FormData
+const formData = new FormData();
+const fileBlob = new Blob(['test content'], { type: 'text/plain' });
+formData.append('file', fileBlob, 'test.txt');
+formData.append('metadata', JSON.stringify({ name: 'Test File' }));
+
+console.log('FormData created with entries:', Array.from(formData.entries()).map(([k]) => k));
+
+// Mock fetch to intercept
+const originalFetch = globalThis.fetch;
+
+globalThis.fetch = async (input, init) => {
+  console.log('\n📦 Fetch intercepted:');
+  console.log('  Input type:', input instanceof Request ? 'Request' : typeof input);
+
+  // If input is a Request object, extract info from it
+  if (input instanceof Request) {
+    console.log('  URL:', input.url);
+    console.log('  Method:', input.method);
+    console.log('  Body type:', input.body?.constructor?.name || 'none');
+    console.log('  Headers:');
+    for (const [key, value] of input.headers.entries()) {
+      console.log(`    ${key}: ${value}`);
+    }
+  } else {
+    console.log('  URL:', typeof input === 'string' ? input : input.url);
+    console.log('  Method:', init?.method || 'GET');
+    console.log('  Body type:', init?.body?.constructor?.name || 'none');
+    console.log('  Body is FormData:', init?.body instanceof FormData);
+
+    const headers = init?.headers;
+    if (headers instanceof Headers) {
+      console.log('  Headers:');
+      for (const [key, value] of headers.entries()) {
+        console.log(`    ${key}: ${value}`);
+      }
+    }
+  }
+
+  // Return proper Response object
+  return new Response(JSON.stringify({ success: true }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+};
+
+try {
+  // Test 1: Direct ky call with FormData using body option
+  console.log('\n✅ Test 1: ky with options.body (FormData)');
+  await ky('https://httpbin.org/post', {
+    method: 'POST',
+    body: formData,
+  });
+
+  console.log('\n✅ Test 2: ky.post with FormData');
+  const formData2 = new FormData();
+  formData2.append('test', 'value');
+
+  await ky.post('https://httpbin.org/post', {
+    body: formData2,
+  });
+
+  console.log('\n✅ Test 3: ky with json option');
+  await ky.post('https://httpbin.org/post', {
+    json: { test: 'value' },
+  });
+
+} catch (error) {
+  console.error('❌ Error:', error.message);
+} finally {
+  globalThis.fetch = originalFetch;
+}
+
+console.log('\n🎉 Ky test complete!\n');

package/test-output/actions.ts

@@ -0,0 +1,134 @@
+"use server";
+
+import { revalidateTag, revalidatePath } from "next/cache";
+import { serverClient } from "./server-client";
+import type {
+  APIEndpoints,
+  ExtractBody,
+  ExtractParams,
+  ExtractResponse,
+} from "./types";
+
+export type ActionResult<T> =
+  | { success: true; data: T }
+  | { success: false; error: string };
+
+/**
+ * Create new session
+ * @tags auth
+ */
+export async function createSessionAction(): Promise<
+  ActionResult<ExtractResponse<APIEndpoints["createSession"]>>
+> {
+  try {
+    const result = await serverClient.createSession();
+
+    // Revalidate related data
+    revalidateTag("auth");
+
+    return { success: true, data: result };
+  } catch (error) {
+    console.error("[Server Action Error]:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Create new user
+ * @tags users
+ */
+export async function createUserAction(
+  body: ExtractBody<APIEndpoints["createUser"]>,
+): Promise<ActionResult<ExtractResponse<APIEndpoints["createUser"]>>> {
+  try {
+    const result = await serverClient.createUser(body);
+
+    // Revalidate related data
+    revalidateTag("users");
+
+    return { success: true, data: result };
+  } catch (error) {
+    console.error("[Server Action Error]:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Update user
+ * @tags users
+ */
+export async function updateUserAction(input: {
+  params: ExtractParams<APIEndpoints["updateUser"]>;
+  body: ExtractBody<APIEndpoints["updateUser"]>;
+}): Promise<ActionResult<ExtractResponse<APIEndpoints["updateUser"]>>> {
+  try {
+    const result = await (serverClient as any).updateUser(
+      input.params,
+      input.body,
+    );
+
+    // Revalidate related data
+    revalidateTag("users");
+
+    return { success: true, data: result };
+  } catch (error) {
+    console.error("[Server Action Error]:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Delete user
+ * @tags users
+ */
+export async function deleteUserAction(
+  params: ExtractParams<APIEndpoints["deleteUser"]>,
+): Promise<ActionResult<ExtractResponse<APIEndpoints["deleteUser"]>>> {
+  try {
+    const result = await serverClient.deleteUser(params);
+
+    // Revalidate related data
+    revalidateTag("users");
+
+    return { success: true, data: result };
+  } catch (error) {
+    console.error("[Server Action Error]:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+
+/**
+ * Refresh access token
+ * @tags auth
+ */
+export async function refreshTokenAction(): Promise<
+  ActionResult<ExtractResponse<APIEndpoints["refreshToken"]>>
+> {
+  try {
+    const result = await serverClient.refreshToken();
+
+    // Revalidate related data
+    revalidateTag("auth");
+
+    return { success: true, data: result };
+  } catch (error) {
+    console.error("[Server Action Error]:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error",
+    };
+  }
+}
+

package/test-output/client.ts

@@ -0,0 +1,81 @@
+'use client';
+
+import { createAPIClient } from '@cushin/api-runtime';
+import type { AuthCallbacks } from '@cushin/api-runtime';
+import { apiConfig } from '../test-real-endpoints.mjs';
+import { z } from 'zod';
+
+// Type the methods based on endpoints
+type APIClientMethods = {
+  [K in keyof typeof apiConfig.endpoints]: (typeof apiConfig.endpoints)[K] extends infer E
+    ? E extends { method: "GET"; params: infer P; query: infer Q; response: infer R }
+      ? (params: P extends z.ZodType ? z.infer<P> : never, query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+      : E extends { method: "GET"; params: infer P; response: infer R }
+        ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+        : E extends { method: "GET"; query: infer Q; response: infer R }
+          ? (query?: Q extends z.ZodType ? z.infer<Q> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+          : E extends { method: "GET"; response: infer R }
+            ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
+            : E extends { method: string; params: infer P; body: infer B; response: infer R }
+              ? (params: P extends z.ZodType ? z.infer<P> : never, body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+              : E extends { method: string; params: infer P; response: infer R }
+                ? (params: P extends z.ZodType ? z.infer<P> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+                : E extends { method: string; body: infer B; response: infer R }
+                  ? (body: B extends z.ZodType ? z.infer<B> : never) => Promise<R extends z.ZodType ? z.infer<R> : never>
+                  : E extends { method: string; response: infer R }
+                    ? () => Promise<R extends z.ZodType ? z.infer<R> : never>
+                    : never
+    : never;
+};
+
+
+// Export singleton instance (will be initialized later)
+export let baseClient: APIClientMethods & {
+  refreshAuth: () => Promise<void>;
+  updateAuthCallbacks: (callbacks: AuthCallbacks) => void;
+};
+
+export const apiClient = {
+  listUsers: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.listUsers.response>>> => 
+    (baseClient as any).listUsers(),
+  getUser: (params: z.infer<NonNullable<typeof apiConfig.endpoints.getUser.params>>): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.getUser.response>>> => 
+    (baseClient as any).getUser(params),
+  searchUsers: (query?: z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.query>>): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.searchUsers.response>>> => 
+    (baseClient as any).searchUsers(query),
+  getUserPosts: (params: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.params>>, query?: z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.query>>): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.getUserPosts.response>>> => 
+    (baseClient as any).getUserPosts(params, query),
+  createSession: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.createSession.response>>> => 
+    (baseClient as any).createSession(),
+  createUser: (body: z.infer<NonNullable<typeof apiConfig.endpoints.createUser.body>>): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.createUser.response>>> => 
+    (baseClient as any).createUser(body),
+  updateUser: (params: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.params>>, body: z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.body>>): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.updateUser.response>>> => 
+    (baseClient as any).updateUser(params, body),
+  deleteUser: (params: z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.params>>): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.deleteUser.response>>> => 
+    (baseClient as any).deleteUser(params),
+  refreshToken: (): Promise<z.infer<NonNullable<typeof apiConfig.endpoints.refreshToken.response>>> => 
+    (baseClient as any).refreshToken(),
+};
+
+/**
+ * Initialize API client with auth callbacks
+ * Call this function in your auth provider setup
+ * 
+ * @example
+ * const authCallbacks = {
+ *   getTokens: () => getStoredTokens(),
+ *   onAuthError: () => router.push('/login'),
+ *   onRefreshToken: async () => {
+ *     await refreshAccessToken();
+ *   },
+ * };
+ * 
+ * initializeAPIClient(authCallbacks);
+ */
+export const initializeAPIClient = (authCallbacks: AuthCallbacks) => {
+  baseClient = createAPIClient(apiConfig, authCallbacks) as any;
+  return baseClient;
+};
+
+// Export for custom usage
+export { createAPIClient };
+export type { AuthCallbacks };