api-def 0.12.0-alpha.5 → 0.12.0-alpha.7

package/bin/index.js

@@ -258551,16 +258551,14 @@ var METHOD_COLORS = {
 var openApiToSourceCode = async (options) => {
   const { openApiPath } = options;
   const inContents = fs.readFileSync(openApiPath, "utf-8");
-  const ast = await openapiTS(inContents, {
-    rootTypes: true
-  });
+  const ast = await openapiTS(inContents, {});
   const bundleResults = await (0, import_openapi_core3.bundle)({
     ref: openApiPath,
     config: await (0, import_openapi_core3.createConfig)({})
   });
   const routes = bundleResults.bundle.parsed.paths;
   const server2 = bundleResults.bundle.parsed.servers[0];
-  let extraTypes = "";
+  const extraTypes = {};
   const source = `import { Api } from "api-def";
 
 const API = new Api({
@@ -258585,14 +258583,18 @@ ${Object.entries(routes).flatMap(([path2, route]) => {
               responseType = mediaType.split(";")[0];
             }
             if (schema?.$ref) {
-              responseTypes.push(`Schema${schema.$ref.split("/").pop()}`);
+              const name = schema.$ref.split("/").pop();
+              extraTypes[`Response${name}`] = `components["schemas"]["${name}"]`;
+              responseTypes.push(`Response${name}`);
             }
           }
         }
       }
       const bodyTypes = [];
       if (methodDef.requestBody?.$ref) {
-        bodyTypes.push(`RequestBody${methodDef.requestBody.$ref.split("/").pop()}`);
+        const name = methodDef.requestBody.$ref.split("/").pop();
+        extraTypes[`Body${name}`] = `components["schemas"]["${name}"]`;
+        bodyTypes.push(`Body${name}`);
       }
       const queryTypes = [];
       if (methodDef.parameters?.length) {
@@ -258608,8 +258610,7 @@ ${Object.entries(routes).flatMap(([path2, route]) => {
           return false;
         });
         if (anyQueryParams) {
-          extraTypes += `export type Query${(0, import_lodash.upperFirst)(id)} = operations["${id}"]["parameters"]["query"];
-`;
+          extraTypes[`Query${(0, import_lodash.upperFirst)(id)}`] = `operations["${id}"]["parameters"]["query"]`;
           queryTypes.push(`Query${(0, import_lodash.upperFirst)(id)}`);
         }
       }
@@ -258627,13 +258628,28 @@ ${Object.entries(routes).flatMap(([path2, route]) => {
           return false;
         });
         if (anyHeaderParams) {
-          extraTypes += `export type Header${(0, import_lodash.upperFirst)(id)} = operations["${id}"]["parameters"]["header"];
-`;
-          requestHeaderTypes.push(`Header${(0, import_lodash.upperFirst)(id)}`);
+          extraTypes[`Headers${(0, import_lodash.upperFirst)(id)}`] = `operations["${id}"]["parameters"]["header"]`;
+          requestHeaderTypes.push(`Headers${(0, import_lodash.upperFirst)(id)}`);
         }
       }
       const responseHeaderTypes = [];
+      let pathParams = [];
+      if (methodDef.parameters?.length) {
+        pathParams = methodDef.parameters.reduce((pathParams2, param) => {
+          if (param.in === "path") {
+            pathParams2.push(param.name);
+          } else if (param.$ref) {
+            const ref = param.$ref;
+            const paramDef = bundleResults.bundle.parsed.components.parameters[ref.split("/").pop()];
+            if (paramDef.in === "path") {
+              pathParams2.push(paramDef.name);
+            }
+          }
+          return pathParams2;
+        }, []);
+      }
       const endpointParts = [
+        pathParams.length > 0 ? `.paramsOf<"${pathParams.join("|")}">()` : "",
         responseTypes.length > 0 ? `.responseOf<${responseTypes.join("|")}>()` : "",
         bodyTypes.length > 0 ? `.bodyOf<${bodyTypes.join("|")}>()` : "",
         queryTypes.length > 0 ? `.queryOf<${queryTypes.join("|")}>()` : "",
@@ -258650,13 +258666,13 @@ ${endpointParts.filter(Boolean).map((part) => `  ${part}`).join("\n")}
     });
   }).join("\n\n")}
 
-export default API;
-    `;
+export default API;`;
   const types = astToString(ast);
+  const extraTypesSource = Object.keys(extraTypes).sort().map((key) => `export type ${key} = ${extraTypes[key]};`).join("\n");
   return `// Type Defs
 
 ${types}
-${extraTypes}
+${extraTypesSource}
 
 //API Def
 

package/cjs/Endpoint.js

@@ -143,10 +143,11 @@ var Endpoint = /** @class */ (function () {
             var keys = Object.keys(request.params);
             for (var i = 0; i < keys.length; i++) {
                 var argName = keys[i];
-                computedPath = computedPath.replace(":".concat(argName), request.params[argName]);
+                var argValue = request.params[argName];
+                computedPath = computedPath.replace(":".concat(argName), argValue).replace("{".concat(argName, "}"), argValue);
             }
         }
-        if (computedPath.includes(":")) {
+        if (computedPath.includes(":") || computedPath.includes("{")) {
             throw new Error("[api-def] Not all path params have been resolved: '".concat(computedPath, "'"));
         }
         return computedPath;

package/esm/Endpoint.js

@@ -64,10 +64,11 @@ export default class Endpoint {
             const keys = Object.keys(request.params);
             for (let i = 0; i < keys.length; i++) {
                 const argName = keys[i];
-                computedPath = computedPath.replace(`:${argName}`, request.params[argName]);
+                const argValue = request.params[argName];
+                computedPath = computedPath.replace(`:${argName}`, argValue).replace(`{${argName}}`, argValue);
             }
         }
-        if (computedPath.includes(":")) {
+        if (computedPath.includes(":") || computedPath.includes("{")) {
             throw new Error(`[api-def] Not all path params have been resolved: '${computedPath}'`);
         }
         return computedPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-def",
-  "version": "0.12.0-alpha.5",
+  "version": "0.12.0-alpha.7",
   "description": "Typed API definitions with middleware support",
   "main": "cjs/index.js",
   "types": "esm/index.d.ts",