cushin-monorepo 3.0.1

package/test-content-type-handling.mjs

@@ -0,0 +1,100 @@
+/**
+ * Comprehensive test for Content-Type handling with JSON and FormData
+ */
+
+import { createAPIClient, defineEndpoint } from './packages/api-runtime/dist/index.js';
+import { z } from 'zod';
+
+console.log('\n🧪 Testing Content-Type Handling\n');
+
+// Define endpoints
+const jsonEndpoint = defineEndpoint({
+  path: 'post',
+  method: 'POST',
+  body: z.object({ message: z.string() }),
+  response: z.any(),
+});
+
+const formDataEndpoint = defineEndpoint({
+  path: 'post',
+  method: 'POST',
+  response: z.any(),
+});
+
+const getEndpoint = defineEndpoint({
+  path: 'get',
+  method: 'GET',
+  response: z.any(),
+});
+
+// Create API client
+const apiClient = createAPIClient({
+  baseUrl: 'https://httpbin.org',
+  endpoints: {
+    jsonRequest: jsonEndpoint,
+    formDataRequest: formDataEndpoint,
+    getRequest: getEndpoint,
+  },
+});
+
+// Track requests
+const requests = [];
+const originalFetch = globalThis.fetch;
+
+globalThis.fetch = async (input, init) => {
+  if (input instanceof Request) {
+    const contentType = input.headers.get('content-type') || input.headers.get('Content-Type');
+    requests.push({
+      url: input.url,
+      method: input.method,
+      contentType,
+    });
+
+    return new Response(JSON.stringify({ success: true }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+
+  return originalFetch(input, init);
+};
+
+try {
+  console.log('Test 1: JSON body with Zod schema');
+  await apiClient.jsonRequest({ message: 'Hello, World!' });
+  console.log('  Method:', requests[0].method);
+  console.log('  Content-Type:', requests[0].contentType);
+  if (requests[0].contentType === 'application/json') {
+    console.log('  ✅ PASS: Content-Type is application/json\n');
+  } else {
+    console.log('  ❌ FAIL: Expected application/json, got', requests[0].contentType, '\n');
+  }
+
+  console.log('Test 2: FormData body');
+  const formData = new FormData();
+  formData.append('file', new Blob(['test'], { type: 'text/plain' }), 'test.txt');
+  await apiClient.formDataRequest(formData);
+  console.log('  Method:', requests[1].method);
+  console.log('  Content-Type:', requests[1].contentType);
+  if (requests[1].contentType && requests[1].contentType.startsWith('multipart/form-data')) {
+    console.log('  ✅ PASS: Content-Type is multipart/form-data with boundary\n');
+  } else {
+    console.log('  ❌ FAIL: Expected multipart/form-data, got', requests[1].contentType, '\n');
+  }
+
+  console.log('Test 3: GET request (no body)');
+  await apiClient.getRequest();
+  console.log('  Method:', requests[2].method);
+  console.log('  Content-Type:', requests[2].contentType);
+  if (requests[2].contentType === 'application/json') {
+    console.log('  ✅ PASS: Content-Type is application/json for GET\n');
+  } else {
+    console.log('  ❌ FAIL: Expected application/json for GET, got', requests[2].contentType, '\n');
+  }
+
+  console.log('✅ All tests passed!\n');
+} catch (error) {
+  console.error('❌ Error:', error);
+} finally {
+  globalThis.fetch = originalFetch;
+}

package/test-endpoints-config.mjs

@@ -0,0 +1,144 @@
+// Test configuration với các endpoint scenarios khác nhau
+// Mock z.object để không cần import zod
+const z = {
+  object: (shape) => ({ _type: "object", shape }),
+  array: (item) => ({ _type: "array", item }),
+  string: () => ({ _type: "string" }),
+  number: () => ({ _type: "number" }),
+  boolean: () => ({ _type: "boolean" }),
+  enum: (...values) => ({ _type: "enum", values }),
+};
+
+z.string.prototype.email = function() { return this; };
+z.number.prototype.optional = function() { return this; };
+z.string.prototype.optional = function() { return this; };
+
+export const testEndpointsConfig = {
+  baseUrl: "https://api.example.com",
+  endpoints: {
+    // Case 1: GET - No params, no query
+    listUsers: {
+      path: "/users",
+      method: "GET",
+      response: z.object({
+        users: z.array(z.object({ id: z.string(), name: z.string() })),
+      }),
+      description: "List all users",
+    },
+
+    // Case 2: GET - Has params only
+    getUser: {
+      path: "/users/:id",
+      method: "GET",
+      params: z.object({ id: z.string() }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      description: "Get user by ID",
+    },
+
+    // Case 3: GET - Has query only
+    searchUsers: {
+      path: "/users/search",
+      method: "GET",
+      query: z.object({
+        q: z.string(),
+        limit: z.number().optional(),
+      }),
+      response: z.object({
+        results: z.array(z.object({ id: z.string(), name: z.string() })),
+      }),
+      description: "Search users",
+    },
+
+    // Case 4: GET - Has params and query
+    getUserPosts: {
+      path: "/users/:id/posts",
+      method: "GET",
+      params: z.object({ id: z.string() }),
+      query: z.object({
+        status: z.enum(["draft", "published"]).optional(),
+        limit: z.number().optional(),
+      }),
+      response: z.object({
+        posts: z.array(z.object({ id: z.string(), title: z.string() })),
+      }),
+      description: "Get user posts",
+    },
+
+    // Case 5: POST - No params, no body (tạo session)
+    createSession: {
+      path: "/sessions",
+      method: "POST",
+      response: z.object({
+        sessionId: z.string(),
+        expiresAt: z.string(),
+      }),
+      tags: ["auth"],
+      description: "Create new session",
+    },
+
+    // Case 6: POST - Has body only
+    createUser: {
+      path: "/users",
+      method: "POST",
+      body: z.object({
+        name: z.string(),
+        email: z.string().email(),
+      }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      tags: ["users"],
+      description: "Create new user",
+    },
+
+    // Case 7: POST - Has params and body
+    updateUser: {
+      path: "/users/:id",
+      method: "POST",
+      params: z.object({ id: z.string() }),
+      body: z.object({
+        name: z.string().optional(),
+        email: z.string().email().optional(),
+      }),
+      response: z.object({
+        id: z.string(),
+        name: z.string(),
+        email: z.string(),
+      }),
+      tags: ["users"],
+      description: "Update user",
+    },
+
+    // Case 8: DELETE - Has params only
+    deleteUser: {
+      path: "/users/:id",
+      method: "DELETE",
+      params: z.object({ id: z.string() }),
+      response: z.object({
+        success: z.boolean(),
+      }),
+      tags: ["users"],
+      description: "Delete user",
+    },
+
+    // Case 9: PATCH - No params, no body (refresh token)
+    refreshToken: {
+      path: "/auth/refresh",
+      method: "PATCH",
+      response: z.object({
+        accessToken: z.string(),
+        refreshToken: z.string(),
+      }),
+      tags: ["auth"],
+      description: "Refresh access token",
+    },
+  },
+};
+
+export default testEndpointsConfig;

package/test-formdata-content-type-protection.mjs

@@ -0,0 +1,127 @@
+/**
+ * Test that Content-Type is NEVER manually set for FormData,
+ * even if endpoint has custom Content-Type header
+ */
+
+import { createAPIClient, defineEndpoint } from './packages/api-runtime/dist/index.js';
+import { z } from 'zod';
+
+console.log('\n🧪 Testing FormData Content-Type Protection\n');
+
+// Define endpoint WITH custom Content-Type header (this should be IGNORED for FormData)
+const uploadWithCustomHeader = defineEndpoint({
+  path: 'post',
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json',  // This should be IGNORED for FormData
+    'X-Custom-Header': 'test-value',     // This should be preserved
+  },
+  response: z.any(),
+});
+
+// Define endpoint WITHOUT custom headers
+const uploadNoHeaders = defineEndpoint({
+  path: 'post',
+  method: 'POST',
+  response: z.any(),
+});
+
+// Create API client
+const apiClient = createAPIClient({
+  baseUrl: 'https://httpbin.org',
+  endpoints: {
+    uploadWithHeader: uploadWithCustomHeader,
+    uploadNoHeader: uploadNoHeaders,
+  },
+});
+
+// Mock fetch to capture requests
+const originalFetch = globalThis.fetch;
+const requests = [];
+
+globalThis.fetch = async (input) => {
+  if (input instanceof Request) {
+    const headers = {};
+    for (const [key, value] of input.headers.entries()) {
+      headers[key] = value;
+    }
+
+    requests.push({
+      url: input.url,
+      method: input.method,
+      headers,
+    });
+
+    return new Response(JSON.stringify({ success: true }), {
+      status: 200,
+      headers: { 'content-type': 'application/json' },
+    });
+  }
+  return originalFetch(input);
+};
+
+try {
+  console.log('Test 1: FormData with endpoint that has Content-Type header');
+  console.log('  Expected: Content-Type should be multipart/form-data (NOT application/json)');
+  console.log('  Expected: Custom headers should still be applied\n');
+
+  const formData1 = new FormData();
+  formData1.append('file', new Blob(['test'], { type: 'text/plain' }), 'test.txt');
+  formData1.append('name', 'Test File');
+
+  await apiClient.uploadWithHeader(formData1);
+
+  const req1 = requests[0];
+  console.log('  Headers sent:');
+  Object.entries(req1.headers).forEach(([key, value]) => {
+    console.log(`    ${key}: ${value}`);
+  });
+
+  const contentType1 = req1.headers['content-type'];
+  const customHeader1 = req1.headers['x-custom-header'];
+
+  if (contentType1 && contentType1.startsWith('multipart/form-data')) {
+    console.log('  ✅ PASS: Content-Type is multipart/form-data with boundary');
+  } else {
+    console.log(`  ❌ FAIL: Content-Type is ${contentType1} (expected multipart/form-data)`);
+    process.exit(1);
+  }
+
+  if (customHeader1 === 'test-value') {
+    console.log('  ✅ PASS: Custom header X-Custom-Header is preserved\n');
+  } else {
+    console.log(`  ❌ FAIL: Custom header X-Custom-Header is ${customHeader1} (expected test-value)\n`);
+    process.exit(1);
+  }
+
+  console.log('Test 2: FormData with endpoint without custom headers');
+  console.log('  Expected: Content-Type should be multipart/form-data\n');
+
+  const formData2 = new FormData();
+  formData2.append('file', new Blob(['test2'], { type: 'text/plain' }), 'test2.txt');
+
+  await apiClient.uploadNoHeader(formData2);
+
+  const req2 = requests[1];
+  console.log('  Headers sent:');
+  Object.entries(req2.headers).forEach(([key, value]) => {
+    console.log(`    ${key}: ${value}`);
+  });
+
+  const contentType2 = req2.headers['content-type'];
+
+  if (contentType2 && contentType2.startsWith('multipart/form-data')) {
+    console.log('  ✅ PASS: Content-Type is multipart/form-data with boundary\n');
+  } else {
+    console.log(`  ❌ FAIL: Content-Type is ${contentType2} (expected multipart/form-data)\n`);
+    process.exit(1);
+  }
+
+  console.log('✅ All tests passed!');
+  console.log('✅ FormData Content-Type is protected from being overridden\n');
+} catch (error) {
+  console.error('❌ Error:', error);
+  process.exit(1);
+} finally {
+  globalThis.fetch = originalFetch;
+}

package/test-formdata-runtime.mjs

@@ -0,0 +1,127 @@
+/**
+ * Test script to verify FormData runtime behavior with Content-Type handling
+ */
+
+import { createAPIClient, defineEndpoint } from './packages/api-runtime/dist/index.js';
+import { z } from 'zod';
+
+console.log('\n🧪 Testing FormData Runtime Behavior\n');
+
+// Define upload endpoint
+const uploadEndpoint = defineEndpoint({
+  path: 'post',  // httpbin.org/post endpoint
+  method: 'POST',
+  response: z.any(),  // httpbin.org returns various fields, so we use z.any() for simplicity
+});
+
+// Create API client
+const apiClient = createAPIClient({
+  baseUrl: 'https://httpbin.org',
+  endpoints: {
+    upload: uploadEndpoint,
+  },
+});
+
+// Test 1: Verify FormData detection
+console.log('✅ Test 1: Create FormData and verify detection');
+const formData = new FormData();
+// Use Blob for file content (Node.js FormData requirement)
+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:', formData instanceof FormData);
+console.log('   FormData entries:', Array.from(formData.entries()).map(([k]) => k));
+
+// Test 2: Mock request to see headers
+console.log('\n✅ Test 2: Inspect request headers (using ky internals)');
+
+// We'll use a mock to intercept the request
+const originalFetch = globalThis.fetch;
+let capturedRequest = null;
+
+globalThis.fetch = async (input, init) => {
+  console.log('   📦 Request intercepted!');
+
+  // Ky uses Request objects, not (url, init) pairs
+  if (input instanceof Request) {
+    console.log('   Input type: Request object');
+    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}`);
+    }
+
+    capturedRequest = { request: input };
+  } else {
+    console.log('   Input type:', typeof input);
+    console.log('   URL:', typeof input === 'string' ? input : input.url);
+    console.log('   Method:', init?.method || 'GET');
+    console.log('   Body:', init?.body);
+    console.log('   Body type:', init?.body?.constructor?.name || 'undefined');
+
+    const headers = init?.headers;
+    if (headers) {
+      console.log('   Headers:');
+      if (headers instanceof Headers) {
+        for (const [key, value] of headers.entries()) {
+          console.log(`     ${key}: ${value}`);
+        }
+      } else if (typeof headers === 'object') {
+        for (const [key, value] of Object.entries(headers)) {
+          console.log(`     ${key}: ${value === undefined ? 'undefined (will be removed)' : value}`);
+        }
+      }
+    } else {
+      console.log('   Headers: (none)');
+    }
+
+    capturedRequest = { input, init };
+  }
+
+  // Return mock response (mock httpbin response)
+  return new Response(JSON.stringify({
+    args: {},
+    files: {},
+    form: {},
+    headers: {},
+    json: null,
+    url: input instanceof Request ? input.url : (typeof input === 'string' ? input : input.url)
+  }), {
+    status: 200,
+    headers: { 'content-type': 'application/json' },
+  });
+};
+
+try {
+  // Make the request - note: upload endpoint is POST method, so we pass body as first parameter
+  console.log('\n📤 Making upload request with FormData...\n');
+  console.log('   Endpoint method:', uploadEndpoint.method);
+  console.log('   Calling apiClient.upload(formData)...');
+
+  await apiClient.upload(formData);
+
+  console.log('\n✅ Test 2 Result:');
+  if (capturedRequest?.request) {
+    const contentType = capturedRequest.request.headers.get('Content-Type') || capturedRequest.request.headers.get('content-type');
+    console.log('   Content-Type in request:', contentType);
+
+    if (contentType && contentType.startsWith('multipart/form-data')) {
+      console.log('   ✅ SUCCESS: Content-Type is correctly set to multipart/form-data with boundary!');
+    } else {
+      console.log('   ❌ FAIL: Content-Type is not multipart/form-data:', contentType);
+    }
+  } else {
+    console.log('   ❌ No request captured');
+  }
+} catch (error) {
+  console.error('   ❌ Error:', error);
+} finally {
+  // Restore original fetch
+  globalThis.fetch = originalFetch;
+}
+
+console.log('\n🎉 Runtime test complete!\n');

package/test-full-integration.mjs

@@ -0,0 +1,90 @@
+import { createAPIClient } from "./packages/api-runtime/dist/client.js";
+import testConfig from "./test-simple-config.mjs";
+
+console.log("=== FULL INTEGRATION TEST ===\n");
+console.log("Testing createAPIClient với các endpoint scenarios khác nhau\n");
+
+const client = createAPIClient(testConfig);
+
+// Helper để test method signatures
+function testMethodSignature(methodName, method) {
+  console.log(`${methodName}:`);
+  console.log(`  - Function length (parameters): ${method.length}`);
+
+  // Extract parameter names bằng cách parse function string
+  const funcStr = method.toString();
+  const paramsMatch = funcStr.match(/\(([^)]*)\)/);
+  const params = paramsMatch ? paramsMatch[1].trim() : "no params";
+  console.log(`  - Parameters: ${params || "() - no parameters"}`);
+  console.log("");
+}
+
+// Test từng endpoint type
+console.log("--- Query Endpoints (GET) ---\n");
+
+testMethodSignature("listUsers (no params, no query)", client.listUsers);
+testMethodSignature("getUser (params only)", client.getUser);
+testMethodSignature("searchUsers (query only)", client.searchUsers);
+testMethodSignature("getUserPosts (params + query)", client.getUserPosts);
+
+console.log("\n--- Mutation Endpoints (POST/DELETE/PATCH) ---\n");
+
+testMethodSignature("createSession (POST, no params, no body)", client.createSession);
+testMethodSignature("createUser (POST, body only)", client.createUser);
+testMethodSignature("updateUser (POST, params + body)", client.updateUser);
+testMethodSignature("deleteUser (DELETE, params only)", client.deleteUser);
+testMethodSignature("refreshToken (PATCH, no params, no body)", client.refreshToken);
+
+// Kiểm tra generated method có đúng không
+console.log("\n--- Verification ---\n");
+
+const expectedSignatures = {
+  listUsers: { length: 0, desc: "no parameters" },
+  getUser: { length: 1, desc: "params" },
+  searchUsers: { length: 1, desc: "query (optional)" },
+  getUserPosts: { length: 2, desc: "params, query (optional)" },
+  createSession: { length: 0, desc: "no parameters" },
+  createUser: { length: 1, desc: "body" },
+  updateUser: { length: 2, desc: "params, body" },
+  deleteUser: { length: 1, desc: "params" },
+  refreshToken: { length: 0, desc: "no parameters" },
+};
+
+let allPass = true;
+for (const [name, expected] of Object.entries(expectedSignatures)) {
+  const actual = client[name].length;
+  const pass = actual === expected.length;
+  allPass = allPass && pass;
+
+  console.log(
+    `${pass ? "✅" : "❌"} ${name}: expected ${expected.length} params (${expected.desc}), got ${actual}`
+  );
+}
+
+console.log("");
+console.log(allPass ? "✅ ALL TESTS PASSED!" : "❌ SOME TESTS FAILED");
+console.log("");
+
+// Demonstrate usage examples
+console.log("\n--- Usage Examples (no actual network calls) ---\n");
+
+console.log("// Query endpoints:");
+console.log("await client.listUsers()                    // ✅ No undefined needed");
+console.log("await client.getUser({ id: '123' })         // ✅ Pass params");
+console.log("await client.searchUsers({ q: 'john' })     // ✅ Pass query");
+console.log("await client.getUserPosts({ id: '1' }, { status: 'published' })");
+console.log("");
+
+console.log("// Mutation endpoints:");
+console.log("await client.createSession()                // ✅ No undefined needed");
+console.log("await client.createUser({ name: 'John', email: 'john@example.com' })");
+console.log("await client.updateUser({ id: '1' }, { name: 'Jane' })");
+console.log("await client.deleteUser({ id: '1' })");
+console.log("await client.refreshToken()                 // ✅ No undefined needed");
+console.log("");
+
+console.log("--- Summary ---\n");
+console.log("✅ Runtime client xử lý tất cả cases chính xác");
+console.log("✅ Không cần pass undefined cho endpoints không có params/body");
+console.log("✅ Method signatures match với endpoint definitions");
+console.log("");

package/test-headers-formdata.mjs

@@ -0,0 +1,97 @@
+/**
+ * Test script to demonstrate custom headers and FormData support
+ */
+
+import { defineEndpoint } from './packages/api-runtime/dist/index.js';
+import { z } from 'zod';
+
+console.log('\n🧪 Testing Custom Headers and FormData Support\n');
+
+// Test 1: Endpoint with custom headers
+console.log('✅ Test 1: Define endpoint with custom headers');
+const apiKeyEndpoint = defineEndpoint({
+  path: '/api/data',
+  method: 'POST',
+  body: z.object({
+    name: z.string(),
+  }),
+  response: z.object({
+    id: z.string(),
+  }),
+  headers: {
+    'X-API-Key': 'test-api-key-123',
+    'X-Custom-Header': 'custom-value',
+  },
+});
+
+console.log('   Endpoint path:', apiKeyEndpoint.path);
+console.log('   Custom headers:', apiKeyEndpoint.headers);
+console.log('   ✓ Custom headers defined successfully\n');
+
+// Test 2: FormData upload endpoint
+console.log('✅ Test 2: Define FormData upload endpoint');
+const uploadEndpoint = defineEndpoint({
+  path: '/users/:userId/avatar',
+  method: 'POST',
+  params: z.object({
+    userId: z.string(),
+  }),
+  response: z.object({
+    avatarUrl: z.string(),
+  }),
+  headers: {
+    'X-Upload-Source': 'test-app',
+  },
+});
+
+console.log('   Endpoint path:', uploadEndpoint.path);
+console.log('   Method:', uploadEndpoint.method);
+console.log('   Custom headers:', uploadEndpoint.headers);
+console.log('   ✓ FormData endpoint defined successfully\n');
+
+// Test 3: Type checking
+console.log('✅ Test 3: Type safety validation');
+try {
+  // This should work - all required fields present
+  const validEndpoint = defineEndpoint({
+    path: '/test',
+    method: 'GET',
+    response: z.object({ data: z.string() }),
+    headers: {
+      'Authorization': 'Bearer token',
+    },
+  });
+  console.log('   ✓ Valid endpoint created with headers\n');
+} catch (error) {
+  console.log('   ✗ Unexpected error:', error.message);
+}
+
+// Test 4: Combined features
+console.log('✅ Test 4: Combined custom headers + FormData + baseUrl override');
+const advancedEndpoint = defineEndpoint({
+  path: '/upload/documents',
+  method: 'POST',
+  baseUrl: 'https://upload.example.com',
+  response: z.object({
+    documentIds: z.array(z.string()),
+  }),
+  headers: {
+    'X-Upload-Type': 'bulk',
+    'X-Client-Version': '1.0.0',
+  },
+  tags: ['uploads', 'documents'],
+  description: 'Bulk document upload',
+});
+
+console.log('   Endpoint path:', advancedEndpoint.path);
+console.log('   Base URL:', advancedEndpoint.baseUrl);
+console.log('   Headers:', advancedEndpoint.headers);
+console.log('   Tags:', advancedEndpoint.tags);
+console.log('   ✓ Advanced endpoint with all features\n');
+
+console.log('🎉 All tests passed!\n');
+console.log('📝 Summary:');
+console.log('   - Custom headers can be added to any endpoint');
+console.log('   - FormData is automatically detected at runtime');
+console.log('   - Headers work with all other endpoint features');
+console.log('   - Type safety is maintained throughout\n');