oazapfts 4.3.3 → 4.4.0

package/README.md

@@ -4,13 +4,16 @@
 
 Generate TypeScript clients to tap into OpenAPI servers.
 
+![](https://avatars.githubusercontent.com/u/119607625?s=200&v=4)
+
 ## Features
 
 - **AST-based**:
   Unlike other code generators `oazapfts` does not use templates to generate code but uses TypeScript's built-in API to generate and pretty-print an abstract syntax tree.
-- **Fast**: The cli does not use any of the common Java-based tooling, so the code generation is super fast.
+- **Fast**: The CLI does not use any of the common Java-based tooling, so the code generation is super fast.
+- **Single file**: All functions and types are co-located in one single self-contained file.
 - **Tree-shakeable**: Individually exported functions allow you to bundle only the ones you actually use.
-- **Human friendly signatures**: The generated api methods don't leak an HTTP-specific implementation details. For example, all optional parameters are grouped together in one object, no matter whether they end up in the headers, path or query-string.
+- **Human friendly signatures**: The generated API methods don't leak any HTTP-specific implementation details. For example, all optional parameters are grouped together in one object, no matter whether they end up in the headers, path or query-string.
 
 ## Installation
 
@@ -18,7 +21,8 @@ Generate TypeScript clients to tap into OpenAPI servers.
 npm install oazapfts
 ```
 
-**NOTE:** With version 3.0.0 oazapfts has become a runtime dependency and the generated code does no longer include all the fetch logic.
+> **Note**
+> With version 3.0.0 oazapfts has become a runtime dependency and the generated code does no longer include all the fetch logic.
 
 ## Usage
 
@@ -36,36 +40,64 @@ Where `<spec>` is the URL or local path of an OpenAPI or Swagger spec (in either
 
 Use the `useEnumType` option to generate typescript enums instead of union of values.
 
-## Overriding the defaults
+## Consuming the generated API
 
-The generated file exports a `defaults` constant that can be used to override the `basePath`, provide a custom `fetch` implementation or to send additional headers with each request:
+For each operation defined in the spec the generated API will export a function with a name matching the `operationId`. If no ID is specified, a reasonable name is generated from the HTTP verb and the path.
 
 ```ts
-import * as api from "./api.ts";
-import nodeFetch from "node-fetch";
+import * as api from "./my-generated-api.ts";
+const res = api.getPetById(1);
+```
 
-api.default.basePath = "https://example.com/api";
+> **Note**
+> If your API is large, and you want to take advantage of tree-shaking to exclude unused code, use individual named imports instead:
 
-api.defaults.headers = {
-  access_token: "secret",
-};
+```ts
+import { getPetById } from "./my-generated-api.ts";
+```
 
-api.defaults.fetch = nodeFetch;
+## Fetch options
+
+The **last argument** of each function is an optional [`RequestOpts`](https://github.com/oazapfts/oazapfts/blob/27b296c6fc28fec4869f1b7e1a4a5585ebbd5ee9/src/runtime/index.ts#L5) object that can be used to pass options to the `fetch` call, for example to pass additional `headers` or an `AbortSignal` to cancel the request later on.
+
+```ts
+const res = getPetById(1, {
+  credentials: "include",
+  headers: {
+    Authorization: `Bearer ${token}`,
+  },
+});
 ```
 
-## Consuming the generated API
+You can also use this to override the default `baseUrl` or to provide a custom `fetch` implementation.
+
+> **Note**
+> Instead of passing custom options to each function call, consider [overwriting the global defaults](#overriding-the-defaults).
+
+## Optimistic vs. explicit responses
+
+Oazapfts supports two different modes to handle results,
+an [explicit](#explicit-mode) mode (the default) and an [optimistic](#optimistic-mode) mode, that makes the response handling less verbose.
+
+## Explicit mode
+
+By default, each function returns an `ApiResponse` object that exposes the `status` code, response `headers` and the `data`.
 
-For each operation defined in the spec the generated API will export a function with a name matching the `operationId`. If no id is specified, a reasonable name is generated from the HTTP verb and the path.
+> **Note**
+> This mode is best suited for APIs that return different types for different response codes or APIs where you need to access not only the response body, but also the response headers. If your API is simple, and you don't need this flexibility, consider using the [optimistic mode](#optimistic-mode) instead.
 
-The **last argument** of each function is an optional `RequestOpts` object that can be used to pass options to the `fetch` call, for example to pass additional headers or an `AbortSignal` to cancel the request later on.
+In explicit mode, each function returns a Promise for an `ApiResponse` which is an object with a `status` and a `data` property, holding the HTTP status code and the properly typed data from the response body.
 
-Each function **returns** a Promise for an `ApiResponse` which is an object with a `status` and a `data` property, holding the HTTP status code and the properly typed data from the response body. Since an operation can return different types depending on the status code, the actual return type is a _union_ of all possible responses, discriminated by their status.
+Since an operation can return different types depending on the status code, the actual return type is a _union_ of all possible responses, discriminated by their status.
 
 Consider the following code generated from the `petstore.json` example:
 
 ```ts
-export function getPetById(petId: number, opts?: RequestOpts) {
-  return fetchJson<
+/**
+ * Find pet by ID
+ */
+export function getPetById(petId: number, opts?: Oazapfts.RequestOpts) {
+  return oazapfts.fetchJson<
     | {
         status: 200;
         data: Pet;
@@ -76,15 +108,14 @@ export function getPetById(petId: number, opts?: RequestOpts) {
       }
     | {
         status: 404;
-        data: string;
       }
-  >(`/pet/${petId}`, {
+  >(`/pet/${encodeURIComponent(petId)}`, {
     ...opts,
   });
 }
 ```
 
-In this case the `data` property is typed as `Pet|string`. We can use a type guard to narrow down the type to `Pet`:
+In this case, the `data` property is typed as `Pet|string`. We can use a type guard to narrow down the type to `Pet`:
 
 ```ts
 const res = await api.getPetById(1);
@@ -115,7 +146,7 @@ await handle(api.getPetById(1), {
 });
 ```
 
-The helper will throw an `HttpError` error for any unhanled status code unless you add a `default` handler:
+The helper will throw an `HttpError` error for any unhandled status code, unless you add a `default` handler:
 
 ```ts
 await handle(api.getPetById(1), {
@@ -128,9 +159,26 @@ await handle(api.getPetById(1), {
 });
 ```
 
-## Optimistic APIs
+## Optimistic mode
+
+You can opt into the _optimistic mode_ by using the `--optimistic` command line argument.
+
+In this mode, each function will return a Promise for the happy path, i.e. the type specified for the first `2xx` response.
+
+Looking back at our Pet Store example from above, consuming the response is now much easier and less verbose:
+
+```ts
+const pet = await api.getPetById(1);
+// pet is now typed as Pet!
+```
+
+In case of a response other than `200` the promise will be rejected with a `HttpError`.
 
-Instead of handling errors right in place we can also use the `ok` helper:
+## Mixing both modes
+
+Sometimes you might want to use the optimistic mode for some of your API calls, but need the full `ApiResponse` for others.
+
+In that case, you can use the `ok`-helper function to selectively apply optimistic response handling:
 
 ```ts
 import { ok } from "oazapfts";
@@ -138,21 +186,34 @@ import { ok } from "oazapfts";
 const pet = await ok(api.getPetById(1));
 ```
 
-With this pattern `pet` will be typed as `Pet` and a `HttpError` will be thrown in case of an error.
+## Overriding the defaults
 
-You can even turn your whole API into an optimistic one:
+The generated file exports a `defaults` constant that can be used to override the `basePath`, provide a custom `fetch` implementation or to send additional `headers` with each request. Basically, you can set a default for any [fetch option](https://developer.mozilla.org/en-US/docs/Web/API/fetch#options) you want.
 
 ```ts
-import { optimistic } from "oazapfts";
-import * as rawApi from "./api.ts";
+import * as api from "./api.ts";
+import nodeFetch from "node-fetch";
 
-const api = optimistic(rawApi);
-const pet = await api.getPetById(1);
+// Override the spec's basePath
+api.defaults.basePath = "https://example.com/api";
+
+// Send this header with each request
+api.defaults.headers = {
+  access_token: "secret",
+};
+
+// Include credentials in CORS requests, too
+api.defaults.credentials = "include";
+
+// Use this instead of the global fetch
+api.defaults.fetch = nodeFetch;
 ```
 
-### CLI
+## Alternatives and integrations
+
+If this library doesn't fit your needs, take a look at [openapi-typescript-codegen](https://github.com/ferdikoomen/openapi-typescript-codegen) which follows a similar philosophy but creates many individual files instead of one single self-contained file.
 
-Since version 3.1.0 you can also use the `--optimistic` flag on the command line to generate an optimistic API by default.
+If your frontend uses React, take a look at [react-api-query](https://www.npmjs.com/package/react-api-query) which makes it easy to use an oazapfts client with React hooks in a convenient and type-safe way.
 
 ## About the name
 

package/lib/codegen/generate.d.ts

@@ -2,28 +2,28 @@ import ts from "typescript";
 import { OpenAPIV3 } from "openapi-types";
 import { Opts } from ".";
 export declare const verbs: string[];
-type ContentType = "json" | "form" | "multipart";
-export declare const contentTypes: Record<string, ContentType>;
+export declare function isMimeType(s: unknown): boolean;
+export declare function isJsonMimeType(mime: string): boolean;
 type SchemaObject = OpenAPIV3.SchemaObject & {
     const?: unknown;
 };
 /**
  * Get the name of a formatter function for a given parameter.
  */
-export declare function getFormatter({ style, explode, }: OpenAPIV3.ParameterObject): "form" | "deep" | "explode" | "space" | "pipe";
+export declare function getFormatter({ style, explode, content, }: OpenAPIV3.ParameterObject): "json" | "form" | "deep" | "explode" | "space" | "pipe";
 export declare function getOperationIdentifier(id?: string): string | undefined;
 /**
  * Create a method name for a given operation, either from its operationId or
  * the HTTP verb and path.
  */
 export declare function getOperationName(verb: string, path: string, operationId?: string): string;
-export declare function isNullable(schema: any): boolean;
-export declare function isReference(obj: any): obj is OpenAPIV3.ReferenceObject;
-export declare function getReference(spec: any, ref: string): any;
+export declare function isNullable(schema?: SchemaObject | OpenAPIV3.ReferenceObject): boolean | undefined;
+export declare function isReference(obj: unknown): obj is OpenAPIV3.ReferenceObject;
 /**
  * If the given object is a ReferenceObject, return the last part of its path.
  */
-export declare function getReferenceName(obj: any): string | undefined;
+export declare function getReferenceName(obj: unknown): string | undefined;
+export declare function toIdentifier(s: string): string;
 /**
  * Create a template string literal from the given OpenAPI urlTemplate.
  * Curly braces in the path are turned into identifier expressions,
@@ -69,12 +69,11 @@ export default class ApiGenerator {
     skip(tags?: string[]): boolean;
     getUniqueAlias(name: string): string;
     getEnumUniqueAlias(name: string, values: string): string;
-    getRefBasename(ref: string): string;
     /**
      * Create a type alias for the schema referenced by the given ReferenceObject
      */
     getRefAlias(obj: OpenAPIV3.ReferenceObject): ts.TypeReferenceNode;
-    getUnionType(variants: (OpenAPIV3.ReferenceObject | SchemaObject)[], discriminator?: OpenAPIV3.DiscriminatorObject): ts.TypeNode;
+    getUnionType(variants: (OpenAPIV3.ReferenceObject | SchemaObject)[], discriminator?: OpenAPIV3.DiscriminatorObject): ts.UnionTypeNode;
     /**
      * Creates a type node from a given schema.
      * Delegates to getBaseTypeFromSchema internally and
@@ -89,7 +88,7 @@ export default class ApiGenerator {
     /**
      * Creates literal type (or union) from an array of values
      */
-    getTypeFromEnum(values: unknown[]): ts.LiteralTypeNode | ts.KeywordTypeNode<ts.KeywordTypeSyntaxKind> | ts.UnionTypeNode;
+    getTypeFromEnum(values: unknown[]): ts.LiteralTypeNode | ts.UnionTypeNode;
     getEnumValuesString(values: string[]): string;
     getTrueEnum(schema: OpenAPIV3.NonArraySchemaObject, propName: string): ts.TypeReferenceNode;
     /**
@@ -97,11 +96,12 @@ export default class ApiGenerator {
      */
     getTypeFromProperties(props: {
         [prop: string]: SchemaObject | OpenAPIV3.ReferenceObject;
-    }, required?: string[], additionalProperties?: boolean | SchemaObject | OpenAPIV3.ReferenceObject): ts.TypeLiteralNode;
+    }, required?: string[], additionalProperties?: boolean | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject): ts.TypeLiteralNode;
     getTypeFromResponses(responses: OpenAPIV3.ResponsesObject): ts.UnionTypeNode;
     getTypeFromResponse(resOrRef: OpenAPIV3.ResponseObject | OpenAPIV3.ReferenceObject): ts.TypeNode;
     getResponseType(responses?: OpenAPIV3.ResponsesObject): "json" | "text" | "blob";
-    getSchemaFromContent(content: any): any;
+    getSchemaFromContent(content: Record<string, OpenAPIV3.MediaTypeObject>): OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
+    getTypeFromParameter(p: OpenAPIV3.ParameterObject): ts.TypeNode;
     wrapResult(ex: ts.Expression): ts.Expression;
     generateApi(): ts.SourceFile;
 }

package/lib/codegen/generate.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.supportDeepObjects = exports.callOazapftsFunction = exports.callQsFunction = exports.createUrlExpression = exports.getReferenceName = exports.getReference = exports.isReference = exports.isNullable = exports.getOperationName = exports.getOperationIdentifier = exports.getFormatter = exports.contentTypes = exports.verbs = void 0;
+exports.supportDeepObjects = exports.callOazapftsFunction = exports.callQsFunction = exports.createUrlExpression = exports.toIdentifier = exports.getReferenceName = exports.isReference = exports.isNullable = exports.getOperationName = exports.getOperationIdentifier = exports.getFormatter = exports.isJsonMimeType = exports.isMimeType = exports.verbs = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const typescript_1 = __importStar(require("typescript"));
 const path_1 = __importDefault(require("path"));
@@ -42,20 +42,34 @@ exports.verbs = [
     "PATCH",
     "TRACE",
 ];
-exports.contentTypes = {
+const contentTypes = {
     "*/*": "json",
     "application/json": "json",
-    "application/hal+json": "json",
-    "application/merge-patch+json": "json",
-    "application/problem+json": "json",
-    "application/geo+json": "json",
     "application/x-www-form-urlencoded": "form",
     "multipart/form-data": "multipart",
 };
+function isMimeType(s) {
+    return typeof s === "string" && /^[^/]+\/[^/]+$/.test(s);
+}
+exports.isMimeType = isMimeType;
+function isJsonMimeType(mime) {
+    return contentTypes[mime] === "json" || /\bjson\b/i.test(mime);
+}
+exports.isJsonMimeType = isJsonMimeType;
 /**
  * Get the name of a formatter function for a given parameter.
  */
-function getFormatter({ style = "form", explode = true, }) {
+function getFormatter({ style = "form", explode = true, content, }) {
+    if (content) {
+        const medias = Object.keys(content);
+        if (medias.length !== 1) {
+            throw new Error("Parameters with content property must specify one media type");
+        }
+        if (!isJsonMimeType(medias[0])) {
+            throw new Error("Parameters with content property must specify a JSON compatible media type");
+        }
+        return "json";
+    }
     if (explode && style === "deepObject")
         return "deep";
     if (explode)
@@ -86,39 +100,52 @@ function getOperationName(verb, path, operationId) {
     if (id)
         return id;
     path = path.replace(/\{(.+?)\}/, "by $1").replace(/\{(.+?)\}/, "and $1");
-    return lodash_1.default.camelCase(`${verb} ${path}`);
+    return toIdentifier(`${verb} ${path}`);
 }
 exports.getOperationName = getOperationName;
 function isNullable(schema) {
-    return !!(schema && schema.nullable);
+    return schema && !isReference(schema) && schema.nullable;
 }
 exports.isNullable = isNullable;
 function isReference(obj) {
-    return obj && "$ref" in obj;
+    return typeof obj === "object" && obj !== null && "$ref" in obj;
 }
 exports.isReference = isReference;
-//See https://swagger.io/docs/specification/using-ref/
-function getReference(spec, ref) {
-    const path = ref
-        .slice(2)
-        .split("/")
-        .map((s) => unescape(s.replace(/~1/g, "/").replace(/~0/g, "~")));
-    const ret = lodash_1.default.get(spec, path);
-    if (typeof ret === "undefined") {
-        throw new Error(`Can't find ${path}`);
+/**
+ * Get the last path component of the given ref.
+ */
+function getRefBasename(ref) {
+    return ref.replace(/.+\//, "");
+}
+/**
+ * Returns a name for the given ref that can be used as basis for a type
+ * alias. This usually is the baseName, unless the ref ends with a number,
+ * in which case the whole ref is returned, with leading non-word characters
+ * being stripped.
+ */
+function getRefName(ref) {
+    const base = getRefBasename(ref);
+    if (/^\d+/.test(base)) {
+        return ref.replace(/^\W+/, "");
     }
-    return ret;
+    return base;
 }
-exports.getReference = getReference;
 /**
  * If the given object is a ReferenceObject, return the last part of its path.
  */
 function getReferenceName(obj) {
     if (isReference(obj)) {
-        return lodash_1.default.camelCase(obj.$ref.split("/").slice(-1)[0]);
+        return getRefBasename(obj.$ref);
     }
 }
 exports.getReferenceName = getReferenceName;
+function toIdentifier(s) {
+    const cc = lodash_1.default.camelCase(s);
+    if (cg.isValidIdentifier(cc))
+        return cc;
+    return "$" + cc;
+}
+exports.toIdentifier = toIdentifier;
 /**
  * Create a template string literal from the given OpenAPI urlTemplate.
  * Curly braces in the path are turned into identifier expressions,
@@ -128,7 +155,7 @@ function createUrlExpression(path, qs) {
     const spans = [];
     // Use a replacer function to collect spans as a side effect:
     const head = path.replace(/(.*?)\{(.+?)\}(.*?)(?=\{|$)/g, (_substr, head, name, literal) => {
-        const expression = lodash_1.default.camelCase(name);
+        const expression = toIdentifier(name);
         spans.push({
             expression: cg.createCall(typescript_1.factory.createIdentifier("encodeURIComponent"), { args: [typescript_1.factory.createIdentifier(expression)] }),
             literal,
@@ -220,7 +247,15 @@ class ApiGenerator {
         if (!ref.startsWith("#/")) {
             throw new Error(`External refs are not supported (${ref}). Make sure to call SwaggerParser.bundle() first.`);
         }
-        return getReference(this.spec, ref);
+        const path = ref
+            .slice(2)
+            .split("/")
+            .map((s) => decodeURI(s.replace(/~1/g, "/").replace(/~0/g, "~")));
+        const resolved = lodash_1.default.get(this.spec, path);
+        if (typeof resolved === "undefined") {
+            throw new Error(`Can't find ${path}`);
+        }
+        return resolved;
     }
     resolveArray(array) {
         return array ? array.map((el) => this.resolve(el)) : [];
@@ -253,9 +288,6 @@ class ApiGenerator {
         }
         return this.getUniqueAlias(name);
     }
-    getRefBasename(ref) {
-        return ref.replace(/.+\//, "");
-    }
     /**
      * Create a type alias for the schema referenced by the given ReferenceObject
      */
@@ -264,12 +296,14 @@ class ApiGenerator {
         let ref = this.refs[$ref];
         if (!ref) {
             const schema = this.resolve(obj);
-            const name = this.getUniqueAlias(lodash_1.default.upperFirst(lodash_1.default.camelCase(schema.title || this.getRefBasename($ref))));
-            ref = this.refs[$ref] = typescript_1.factory.createTypeReferenceNode(name, undefined);
+            const name = schema.title || getRefName($ref);
+            const identifier = lodash_1.default.upperFirst(toIdentifier(name));
+            const alias = this.getUniqueAlias(identifier);
+            ref = this.refs[$ref] = typescript_1.factory.createTypeReferenceNode(alias, undefined);
             const type = this.getTypeFromSchema(schema);
             this.aliases.push(cg.createTypeAliasDeclaration({
                 modifiers: [cg.modifier.export],
-                name,
+                name: alias,
                 type,
             }));
         }
@@ -284,7 +318,7 @@ class ApiGenerator {
             // By default, the last component of the ref name (i.e., after the last trailing slash) is
             // used as the discriminator value for each variant. This can be overridden using the
             // discriminator.mapping property.
-            const mappedValues = new Set(Object.values(discriminator.mapping || {}).map((ref) => this.getRefBasename(ref)));
+            const mappedValues = new Set(Object.values(discriminator.mapping || {}).map(getRefBasename));
             return typescript_1.factory.createUnionTypeNode([
                 ...Object.entries(discriminator.mapping || {}).map(([discriminatorValue, variantRef]) => [
                     discriminatorValue,
@@ -297,10 +331,10 @@ class ApiGenerator {
                         // considered."
                         throw new Error("Discriminators require references, not inline schemas");
                     }
-                    return !mappedValues.has(this.getRefBasename(variant.$ref));
+                    return !mappedValues.has(getRefBasename(variant.$ref));
                 })
                     .map((schema) => [
-                    this.getRefBasename(schema.$ref),
+                    getRefBasename(schema.$ref),
                     schema,
                 ]),
             ].map(([discriminatorValue, variant]) => 
@@ -367,9 +401,10 @@ class ApiGenerator {
             return this.getTypeFromProperties(schema.properties || {}, schema.required, schema.additionalProperties);
         }
         if (schema.enum) {
-            return this.opts.useEnumType && name && schema.type != "boolean"
+            // enum -> enum or union
+            return this.opts.useEnumType && name && schema.type !== "boolean"
                 ? this.getTrueEnum(schema, name)
-                : this.getTypeFromEnum(schema.enum);
+                : cg.createEnumTypeNode(schema.enum);
         }
         if (schema.format == "binary") {
             return typescript_1.factory.createTypeReferenceNode("Blob", []);
@@ -379,10 +414,10 @@ class ApiGenerator {
         }
         if (schema.type) {
             // string, boolean, null, number
-            if (schema.type in cg.keywordType)
-                return cg.keywordType[schema.type];
             if (schema.type === "integer")
                 return cg.keywordType.number;
+            if (schema.type in cg.keywordType)
+                return cg.keywordType[schema.type];
         }
         return cg.keywordType.any;
     }
@@ -497,13 +532,13 @@ class ApiGenerator {
             return "text";
         const resolvedResponses = Object.values(responses).map((response) => this.resolve(response));
         // if no content is specified, assume `text` (backwards-compatibility)
-        if (!resolvedResponses.some((res) => { var _a; return Object.keys((_a = res.content) !== null && _a !== void 0 ? _a : []).length > 0; })) {
+        if (!resolvedResponses.some((res) => { var _a; return Object.keys((_a = res.content) !== null && _a !== void 0 ? _a : {}).length > 0; })) {
             return "text";
         }
         const isJson = resolvedResponses.some((response) => {
             var _a;
             const responseMimeTypes = Object.keys((_a = response.content) !== null && _a !== void 0 ? _a : {});
-            return responseMimeTypes.some((mimeType) => exports.contentTypes[mimeType] === "json");
+            return responseMimeTypes.some(isJsonMimeType);
         });
         // if there’s `application/json` or `*/*`, assume `json`
         if (isJson) {
@@ -517,13 +552,12 @@ class ApiGenerator {
         return "blob";
     }
     getSchemaFromContent(content) {
-        const contentType = Object.keys(exports.contentTypes).find((t) => t in content);
-        let schema;
+        const contentType = Object.keys(content).find(isMimeType);
         if (contentType) {
-            schema = lodash_1.default.get(content, [contentType, "schema"]);
-        }
-        if (schema) {
-            return schema;
+            const { schema } = content[contentType];
+            if (schema) {
+                return schema;
+            }
         }
         // if no content is specified -> string
         // `text/*` -> string
@@ -534,6 +568,13 @@ class ApiGenerator {
         // rest (e.g. `application/octet-stream`, `application/gzip`, …) -> binary
         return { type: "string", format: "binary" };
     }
+    getTypeFromParameter(p) {
+        if (p.content) {
+            const schema = this.getSchemaFromContent(p.content);
+            return this.getTypeFromSchema(schema);
+        }
+        return this.getTypeFromSchema(isReference(p) ? p : p.schema);
+    }
     wrapResult(ex) {
         var _a;
         return ((_a = this.opts) === null || _a === void 0 ? void 0 : _a.optimistic) ? callOazapftsFunction("ok", [ex]) : ex;
@@ -581,10 +622,13 @@ class ApiGenerator {
                     name += count;
                 }
                 // merge item and op parameters
-                const resolvedParameters = [
-                    ...this.resolveArray(item.parameters),
-                    ...this.resolveArray(op.parameters),
-                ];
+                const resolvedParameters = this.resolveArray(item.parameters);
+                for (const p of this.resolveArray(op.parameters)) {
+                    const existing = resolvedParameters.find((r) => r.name === p.name && r.in === p.in);
+                    if (!existing) {
+                        resolvedParameters.push(p);
+                    }
+                }
                 // expand older OpenAPI parameters into deepObject style where needed
                 const parameters = this.isConverted
                     ? supportDeepObjects(resolvedParameters)
@@ -592,16 +636,24 @@ class ApiGenerator {
                 // split into required/optional
                 const [required, optional] = lodash_1.default.partition(parameters, "required");
                 // convert parameter names to argument names ...
-                const argNames = {};
-                parameters
-                    .map((p) => p.name)
-                    .sort((a, b) => a.length - b.length)
-                    .forEach((name) => {
-                    argNames[name] = lodash_1.default.camelCase(name);
+                const argNames = new Map();
+                lodash_1.default.sortBy(parameters, "name.length").forEach((p) => {
+                    const identifier = toIdentifier(p.name);
+                    const existing = [...argNames.values()];
+                    const suffix = existing.includes(identifier)
+                        ? lodash_1.default.upperFirst(p.in)
+                        : "";
+                    argNames.set(p, identifier + suffix);
                 });
+                const getArgName = (param) => {
+                    const name = argNames.get(param);
+                    if (!name)
+                        throw new Error(`Can't find parameter: ${param.name}`);
+                    return name;
+                };
                 // build the method signature - first all the required parameters
-                const methodParams = required.map((p) => cg.createParameter(argNames[this.resolve(p).name], {
-                    type: this.getTypeFromSchema(isReference(p) ? p : p.schema),
+                const methodParams = required.map((p) => cg.createParameter(getArgName(this.resolve(p)), {
+                    type: this.getTypeFromParameter(p),
                 }));
                 let body;
                 let bodyVar;
@@ -610,7 +662,7 @@ class ApiGenerator {
                     body = this.resolve(requestBody);
                     const schema = this.getSchemaFromContent(body.content);
                     const type = this.getTypeFromSchema(schema);
-                    bodyVar = lodash_1.default.camelCase(type.name || getReferenceName(schema) || "body");
+                    bodyVar = toIdentifier(type.name || getReferenceName(schema) || "body");
                     methodParams.push(cg.createParameter(bodyVar, {
                         type,
                         questionToken: !body.required,
@@ -620,12 +672,12 @@ class ApiGenerator {
                 if (optional.length) {
                     methodParams.push(cg.createParameter(cg.createObjectBinding(optional
                         .map((param) => this.resolve(param))
-                        .map(({ name }) => ({ name: argNames[name] }))), {
+                        .map((param) => ({ name: getArgName(param) }))), {
                         initializer: typescript_1.factory.createObjectLiteralExpression(),
                         type: typescript_1.factory.createTypeLiteralNode(optional.map((p) => cg.createPropertySignature({
-                            name: argNames[this.resolve(p).name],
+                            name: getArgName(this.resolve(p)),
                             questionToken: true,
-                            type: this.getTypeFromSchema(isReference(p) ? p : p.schema),
+                            type: this.getTypeFromParameter(p),
                         }))),
                     }));
                 }
@@ -636,16 +688,14 @@ class ApiGenerator {
                 // Next, build the method body...
                 const returnType = this.getResponseType(responses);
                 const query = parameters.filter((p) => p.in === "query");
-                const header = parameters
-                    .filter((p) => p.in === "header")
-                    .map((p) => p.name);
+                const header = parameters.filter((p) => p.in === "header");
                 let qs;
                 if (query.length) {
                     const paramsByFormatter = lodash_1.default.groupBy(query, getFormatter);
                     qs = callQsFunction("query", Object.entries(paramsByFormatter).map(([format, params]) => {
                         //const [allowReserved, encodeReserved] = _.partition(params, "allowReserved");
                         return callQsFunction(format, [
-                            cg.createObjectLiteral(params.map((p) => [p.name, argNames[p.name]])),
+                            cg.createObjectLiteral(params.map((p) => [p.name, getArgName(p)])),
                         ]);
                     }));
                 }
@@ -662,12 +712,12 @@ class ApiGenerator {
                 if (header.length) {
                     init.push(typescript_1.factory.createPropertyAssignment("headers", typescript_1.factory.createObjectLiteralExpression([
                         typescript_1.factory.createSpreadAssignment(typescript_1.factory.createLogicalAnd(typescript_1.factory.createIdentifier("opts"), typescript_1.factory.createPropertyAccessExpression(typescript_1.factory.createIdentifier("opts"), "headers"))),
-                        ...header.map((name) => cg.createPropertyAssignment(name, typescript_1.factory.createIdentifier(argNames[name]))),
+                        ...header.map((param) => cg.createPropertyAssignment(param.name, typescript_1.factory.createIdentifier(getArgName(param)))),
                     ], true)));
                 }
                 const args = [url];
                 if (init.length) {
-                    const m = Object.entries(exports.contentTypes).find(([type]) => {
+                    const m = Object.entries(contentTypes).find(([type]) => {
                         return !!lodash_1.default.get(body, ["content", type]);
                     });
                     const initObj = typescript_1.factory.createObjectLiteralExpression(init, true);