@sungen/driver-api 3.1.2-beta.122 → 3.1.2-beta.124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sungen/driver-api",
-  "version": "3.1.2-beta.122",
+  "version": "3.1.2-beta.124",
   "description": "Sungen API capability — the @api annotation, API catalog, OpenAPI import + `sungen api import`, and the specs/api.ts runtime template. Plugs into @sun-asterisk/sungen via the capability SPI.",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -13,7 +13,7 @@
   "author": "eqe team (engineer & quality) — Sun Asterisk",
   "license": "MIT",
   "dependencies": {
-    "@sun-asterisk/sungen": "3.1.2-beta.122",
+    "@sun-asterisk/sungen": "3.1.2-beta.124",
     "commander": "^14.0.2",
     "yaml": "^2.8.2"
   },

package/src/api-catalog.ts

@@ -27,6 +27,7 @@ export interface ApiEntry {
   method: HttpMethod;
   path: string;
   body?: unknown;
+  encoding?: 'json' | 'form' | 'multipart'; // request-body wire format (default json); form = application/x-www-form-urlencoded
   headers?: Record<string, string>; // per-endpoint header templates; `:param` tokens bind at runtime (flow auth, e.g. authorization: "Bearer :token")
   params: string[];
   expect?: { status?: number | string };
@@ -89,6 +90,7 @@ function parseEntries(file: string, scope: 'screen' | 'shared'): Map<string, Api
       method: String(v.method).toUpperCase() as HttpMethod,
       path: v.path,
       body: v.body,
+      encoding: v.encoding === 'form' || v.encoding === 'multipart' ? v.encoding : undefined, // default (undefined) = json
       headers: v.headers && typeof v.headers === 'object' ? Object.fromEntries(Object.entries(v.headers).map(([k, hv]) => [k, String(hv)])) : undefined,
       params: Array.isArray(v.params) ? v.params.map((p: any) => String(p)) : [],
       expect: v.expect && typeof v.expect === 'object' ? { status: v.expect.status } : undefined,

package/src/index.ts

@@ -85,7 +85,9 @@ function apiPreconditionCodegen(input: { tags: string[]; screenName: string; cwd
     // their `:param` placeholders bind at runtime from the same params — this is the flow auth/token
     // mechanism (the dynamic value comes via an override like `token={{login.body.token}}`).
     const hdr = entry.headers && Object.keys(entry.headers).length ? `, headers: ${JSON.stringify(entry.headers)}` : '';
-    const req = `{ method: ${JSON.stringify(entry.method)}, path: ${JSON.stringify(entry.path)}${entry.body !== undefined ? `, body: ${JSON.stringify(entry.body)}` : ''}${hdr}, datasource: ${ds} }`;
+    // request-body wire format (default json); `form` → x-www-form-urlencoded, `multipart` → form-data (#345).
+    const enc = entry.encoding ? `, encoding: ${JSON.stringify(entry.encoding)}` : '';
+    const req = `{ method: ${JSON.stringify(entry.method)}, path: ${JSON.stringify(entry.path)}${entry.body !== undefined ? `, body: ${JSON.stringify(entry.body)}` : ''}${enc}${hdr}, datasource: ${ds} }`;
     // @concurrent:N → callN (N parallel calls, aggregate result); else a single call. @hybrid adds
     // the storageState opts so the request reuses the UI auth session.
     const callExpr = concurrent

package/src/openapi-import.ts

@@ -14,6 +14,7 @@ export interface ImportedApiEntry {
   path: string;
   params?: string[];
   body?: Record<string, string>;
+  encoding?: 'form' | 'multipart'; // set when the requestBody is form/multipart (json omitted = default)
   expect?: { status: number };
 }
 
@@ -52,16 +53,24 @@ function expectedStatus(responses: Record<string, unknown> | undefined): number
   return success ?? codes[0];
 }
 
-/** JSON-body property names → a `{ prop: ":prop" }` template (best-effort from requestBody schema). */
-function bodyTemplate(op: any): { body?: Record<string, string>; props: string[] } {
-  const schema = op?.requestBody?.content?.['application/json']?.schema;
+/** Body property names → a `{ prop: ":prop" }` template, + the wire encoding (json | form | multipart),
+ *  best-effort from the requestBody content-type (#345). JSON is the default (encoding omitted). */
+function bodyTemplate(op: any): { body?: Record<string, string>; props: string[]; encoding?: 'form' | 'multipart' } {
+  const content = op?.requestBody?.content ?? {};
+  // Prefer JSON; else fall back to form-urlencoded / multipart (those set encoding).
+  const pick = content['application/json'] ? { ct: 'application/json' as const, encoding: undefined }
+    : content['application/x-www-form-urlencoded'] ? { ct: 'application/x-www-form-urlencoded' as const, encoding: 'form' as const }
+      : content['multipart/form-data'] ? { ct: 'multipart/form-data' as const, encoding: 'multipart' as const }
+        : undefined;
+  if (!pick) return { props: [] };
+  const schema = content[pick.ct]?.schema;
   const props = schema && typeof schema === 'object' && schema.properties && typeof schema.properties === 'object'
     ? Object.keys(schema.properties)
     : [];
-  if (!props.length) return { props: [] };
+  if (!props.length) return { props: [], encoding: pick.encoding };
   const body: Record<string, string> = {};
   for (const p of props) body[p] = `:${p}`;
-  return { body, props };
+  return { body, props, encoding: pick.encoding };
 }
 
 export interface ImportResult {
@@ -89,7 +98,7 @@ export function importOpenApi(doc: any, datasource = 'app_api'): ImportResult {
 
       const catalogPath = toCatalogPath(rawPath);
       const pathParams = (catalogPath.match(/:([A-Za-z_][A-Za-z0-9_]*)/g) || []).map((s) => s.slice(1));
-      const { body, props } = bodyTemplate(op);
+      const { body, props, encoding } = bodyTemplate(op);
       const params = [...new Set([...pathParams, ...props])];
 
       let name = typeof op.operationId === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(op.operationId)
@@ -107,6 +116,7 @@ export function importOpenApi(doc: any, datasource = 'app_api'): ImportResult {
         path: catalogPath,
         ...(params.length ? { params } : {}),
         ...(body ? { body } : {}),
+        ...(encoding ? { encoding } : {}),
         ...(status != null ? { expect: { status } } : {}),
       };
     }