keryx 0.11.6 → 0.12.0

package/classes/Connection.ts

@@ -80,8 +80,8 @@ export class Connection<
    *
    * @param actionName - The name of the action to run. If not found, throws
    *   `ErrorType.CONNECTION_ACTION_NOT_FOUND`.
-   * @param params - Raw `FormData` from the HTTP request or WebSocket message.
-   *   Validated and coerced against the action's `inputs` Zod schema.
+   * @param params - Raw parameters as a plain object. Validated and coerced
+   *   against the action's `inputs` Zod schema.
    * @param method - The HTTP method of the incoming request (used for logging).
    * @param url - The request URL (used for logging).
    * @returns The action response and optional error.
@@ -89,7 +89,7 @@ export class Connection<
    */
   async act(
     actionName: string | undefined,
-    params: FormData, // note: params are not constant for all connections - some are long-lived, like websockets
+    params: Record<string, unknown>,
     method: Request["method"] = "",
     url: string = "",
   ): Promise<{ response: Object; error?: TypedError }> {
@@ -279,24 +279,9 @@ export class Connection<
     return api.actions.actions.find((a: Action) => a.name === actionName);
   }
 
-  private async formatParams(params: FormData, action: Action) {
+  private async formatParams(params: Record<string, unknown>, action: Action) {
     if (!action.inputs) return {} as ActionParams<Action>;
 
-    // Convert FormData to a plain object for processing
-    const rawParams: Record<string, any> = {};
-    params.forEach((value, key) => {
-      if (rawParams[key] !== undefined) {
-        // If the key already exists, convert to array
-        if (Array.isArray(rawParams[key])) {
-          rawParams[key].push(value);
-        } else {
-          rawParams[key] = [rawParams[key], value];
-        }
-      } else {
-        rawParams[key] = value;
-      }
-    });
-
     // Handle zod schema inputs
     if (
       typeof action.inputs === "object" &&
@@ -305,12 +290,12 @@ export class Connection<
     ) {
       // This is a zod schema - use safeParseAsync to support both sync and async transforms
       try {
-        const result = await (action.inputs as any).safeParseAsync(rawParams);
+        const result = await (action.inputs as any).safeParseAsync(params);
         if (!result.success) {
           // Get the first validation error (Zod v4 uses .issues instead of .errors)
           const firstError = result.error.issues[0];
           const key = firstError.path[0];
-          const value = rawParams[key];
+          const value = params[key];
           let message = firstError.message;
           // Zod v4: detect missing required param (code: "invalid_type" with undefined input)
           const isMissingRequired =
@@ -405,7 +390,10 @@ function logAction(opts: {
 
 const REDACTED = "[[secret]]" as const;
 
-const sanitizeParams = (params: FormData, action: Action | undefined) => {
+const sanitizeParams = (
+  params: Record<string, unknown>,
+  action: Action | undefined,
+) => {
   const sanitizedParams: Record<string, any> = {};
 
   // Get secret fields from the action's zod schema if it exists
@@ -422,13 +410,13 @@ const sanitizeParams = (params: FormData, action: Action | undefined) => {
     }
   }
 
-  params.forEach((v, k) => {
+  for (const [k, v] of Object.entries(params)) {
     if (secretFields.has(k)) {
       sanitizedParams[k] = REDACTED;
     } else {
       sanitizedParams[k] = v;
     }
-  });
+  }
 
   return sanitizedParams;
 };

package/initializers/mcp.ts

@@ -391,20 +391,10 @@ function createMcpServer(): McpServer {
             await connection.updateSession({ userId: authInfo.extra.userId });
           }
 
-          const params = new FormData();
-          if (args && typeof args === "object") {
-            for (const [key, value] of Object.entries(
-              args as Record<string, unknown>,
-            )) {
-              if (Array.isArray(value)) {
-                for (const item of value) {
-                  params.append(key, String(item));
-                }
-              } else if (value !== undefined && value !== null) {
-                params.set(key, String(value));
-              }
-            }
-          }
+          const params =
+            args && typeof args === "object"
+              ? (args as Record<string, unknown>)
+              : {};
 
           const { response, error } = await connection.act(
             action.name,

package/initializers/resque.ts

@@ -279,7 +279,7 @@ export class Resque extends Initializer {
 
   /**
    * Wrap an action as a node-resque job. Creates a temporary `Connection` with type `"resque"`,
-   * converts inputs to `FormData`, and runs the action via `connection.act()`. Handles
+   * converts inputs to a plain object, and runs the action via `connection.act()`. Handles
    * fan-out result/error collection and recurring task re-enqueue.
    */
   wrapActionAsJob = (
@@ -302,26 +302,21 @@ export class Resque extends Initializer {
           connection.correlationId = propagatedCorrelationId;
         }
 
-        const paramsAsFormData = new FormData();
+        const plainParams: Record<string, unknown> =
+          typeof params === "object" && params !== null
+            ? Object.fromEntries(
+                typeof params.entries === "function"
+                  ? params.entries()
+                  : Object.entries(params),
+              )
+            : {};
 
-        if (typeof params.entries === "function") {
-          for (const [key, value] of params.entries()) {
-            paramsAsFormData.append(key, value);
-          }
-        } else if (typeof params === "object" && params !== null) {
-          for (const [key, value] of Object.entries(params)) {
-            if (value !== undefined && value !== null) {
-              paramsAsFormData.append(key, String(value));
-            }
-          }
-        }
-
-        const fanOutId = params._fanOutId as string | undefined;
+        const fanOutId = plainParams._fanOutId as string | undefined;
 
         let response: Awaited<ReturnType<(typeof action)["run"]>>;
         let error: TypedError | undefined;
         try {
-          const payload = await connection.act(action.name, paramsAsFormData);
+          const payload = await connection.act(action.name, plainParams);
           response = payload.response;
           error = payload.error;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keryx",
-  "version": "0.11.6",
+  "version": "0.12.0",
   "module": "index.ts",
   "type": "module",
   "license": "MIT",

package/util/cli.ts

@@ -241,10 +241,7 @@ async function runActionViaCLI(options: Record<string, string>, command: any) {
 
   const id = "cli:" + os.userInfo().username;
   const connection = new Connection("cli", id);
-  const params = new FormData();
-  for (const [key, value] of Object.entries(options)) {
-    params.append(key, value);
-  }
+  const params: Record<string, unknown> = { ...options };
 
   const { response, error } = await connection.act(actionName, params);
   const payload: { response: any; error?: any } = { response };

package/util/oauthHandlers.ts

@@ -252,11 +252,11 @@ export async function handleAuthorizePost(
     return renderAuthPage(oauthParams, templates, authActions);
   }
 
-  // Build action FormData from all non-OAuth fields
-  const actionParams = new FormData();
+  // Build action params from all non-OAuth fields
+  const actionParams: Record<string, unknown> = {};
   for (const [key, value] of Object.entries(fields)) {
     if (!OAUTH_FIELDS.has(key)) {
-      actionParams.set(key, value);
+      actionParams[key] = value;
     }
   }
 

package/util/webRouting.ts

@@ -64,25 +64,30 @@ export async function determineActionName(
 
 /**
  * Parse request parameters from path params, request body (JSON or form-data),
- * and query string into a single `FormData` instance.
+ * and query string into a single plain object.
+ *
+ * JSON bodies are preserved with full type fidelity (nested objects, arrays,
+ * booleans, numbers). FormData bodies (multipart/form-data and
+ * application/x-www-form-urlencoded) are converted to a plain object where
+ * repeated keys become arrays and `File` values are preserved.
  *
  * @param req - The incoming HTTP request.
  * @param url - The parsed URL (for query string).
  * @param pathParams - Path parameters extracted by route matching.
- * @returns A `FormData` containing all merged parameters.
+ * @returns A plain object containing all merged parameters.
  */
 export async function parseRequestParams(
   req: Request,
   url: ReturnType<typeof parse>,
   pathParams?: Record<string, string>,
-): Promise<FormData> {
-  // param load order: path params -> url params -> body params -> query params
-  let params = new FormData();
+): Promise<Record<string, unknown>> {
+  // param load order: path params -> body params -> query params
+  const params: Record<string, unknown> = {};
 
-  // Add path parameters
+  // Add path parameters (always strings from URL segments)
   if (pathParams) {
     for (const [key, value] of Object.entries(pathParams)) {
-      params.set(key, String(value));
+      params[key] = String(value);
     }
   }
 
@@ -92,20 +97,9 @@ export async function parseRequestParams(
   ) {
     try {
       const bodyContent = (await req.json()) as Record<string, unknown>;
+      // Merge JSON body directly — preserves types (objects, arrays, booleans, numbers)
       for (const [key, value] of Object.entries(bodyContent)) {
-        if (Array.isArray(value)) {
-          // Handle arrays by appending each element
-          if (value.length === 0) {
-            // For empty arrays, set an empty string to indicate the field exists
-            params.set(key, "");
-          } else {
-            for (const item of value) {
-              params.append(key, item);
-            }
-          }
-        } else {
-          params.set(key, value as any);
-        }
+        params[key] = value;
       }
     } catch (e) {
       throw new TypedError({
@@ -123,7 +117,15 @@ export async function parseRequestParams(
   ) {
     const f = await req.formData();
     f.forEach((value, key) => {
-      params.append(key, value);
+      if (params[key] !== undefined) {
+        if (Array.isArray(params[key])) {
+          (params[key] as unknown[]).push(value);
+        } else {
+          params[key] = [params[key], value];
+        }
+      } else {
+        params[key] = value;
+      }
     });
   }
 
@@ -131,9 +133,25 @@ export async function parseRequestParams(
     for (const [key, values] of Object.entries(url.query)) {
       if (values !== undefined) {
         if (Array.isArray(values)) {
-          for (const v of values) params.append(key, v);
+          if (params[key] !== undefined) {
+            if (Array.isArray(params[key])) {
+              (params[key] as unknown[]).push(...values);
+            } else {
+              params[key] = [params[key], ...values];
+            }
+          } else {
+            params[key] = values;
+          }
         } else {
-          params.append(key, values);
+          if (params[key] !== undefined) {
+            if (Array.isArray(params[key])) {
+              (params[key] as unknown[]).push(values);
+            } else {
+              params[key] = [params[key], values];
+            }
+          } else {
+            params[key] = values;
+          }
         }
       }
     }

package/util/webSocket.ts

@@ -25,10 +25,7 @@ export async function handleWebsocketAction(
   ws: ServerWebSocket,
   formattedMessage: ActionParams<any>,
 ) {
-  const params = new FormData();
-  for (const [key, value] of Object.entries(formattedMessage.params)) {
-    params.append(key, value as string);
-  }
+  const params = (formattedMessage.params ?? {}) as Record<string, unknown>;
 
   const { response, error } = await connection.act(
     formattedMessage.action,