oazapfts 5.1.6 → 5.1.7

package/lib/codegen/generate.d.ts

@@ -1,32 +1,41 @@
 import ts from "typescript";
-import { OpenAPIV3 } from "openapi-types";
+import { OpenAPIV3, OpenAPIV3_1 } from "openapi-types";
 import { Opts } from ".";
 export declare const verbs: string[];
 type ContentType = "json" | "form" | "multipart";
 type OnlyMode = "readOnly" | "writeOnly";
 type OnlyModes = Record<OnlyMode, boolean>;
+type OpenAPISchemaObject = OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject;
+type OpenAPIReferenceObject = OpenAPIV3.ReferenceObject | OpenAPIV3_1.ReferenceObject;
+type OpenAPIParameterObject = OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject;
+type OpenAPIDocument = OpenAPIV3.Document | OpenAPIV3_1.Document;
+type OpenAPIDiscriminatorObject = OpenAPIV3.DiscriminatorObject | OpenAPIV3_1.DiscriminatorObject;
+type OpenAPIResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject;
+type OpenAPIResponsesObject = OpenAPIV3.ResponsesObject | OpenAPIV3_1.ResponsesObject;
+type OpenAPIRequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject;
+type OpenAPIMediaTypeObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject;
 export declare function isMimeType(s: unknown): boolean;
 export declare function isJsonMimeType(mime: string): boolean;
-export declare function getBodyFormatter(body?: OpenAPIV3.RequestBodyObject): ContentType | undefined;
-type SchemaObject = OpenAPIV3.SchemaObject & {
+export declare function getBodyFormatter(body?: OpenAPIRequestBodyObject): ContentType | undefined;
+type SchemaObject = OpenAPISchemaObject & {
     const?: unknown;
     "x-enumNames"?: string[];
     "x-enum-varnames"?: string[];
     "x-component-ref-path"?: string;
-    prefixItems?: (OpenAPIV3.ReferenceObject | SchemaObject)[];
+    prefixItems?: (OpenAPIReferenceObject | SchemaObject)[];
 };
 /**
  * Get the name of a formatter function for a given parameter.
  */
-export declare function getFormatter({ style, explode, content, }: OpenAPIV3.ParameterObject): "json" | "form" | "deep" | "explode" | "space" | "pipe";
+export declare function getFormatter({ style, explode, content, }: OpenAPIParameterObject): "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?: SchemaObject | OpenAPIV3.ReferenceObject): boolean | undefined;
-export declare function isReference(obj: unknown): obj is OpenAPIV3.ReferenceObject;
+export declare function isNullable(schema?: SchemaObject | OpenAPIReferenceObject): boolean | undefined;
+export declare function isReference(obj: unknown): obj is OpenAPIReferenceObject;
 /**
  * Converts a local reference path into an array of property names.
  */
@@ -55,16 +64,16 @@ export declare function callOazapftsFunction(name: string, args: ts.Expression[]
  * deeply nested objects. As a workaround we detect parameters that contain
  * square brackets and merge them into a single object.
  */
-export declare function supportDeepObjects(params: OpenAPIV3.ParameterObject[]): OpenAPIV3.ParameterObject[];
+export declare function supportDeepObjects(params: OpenAPIParameterObject[]): OpenAPIV3.ParameterObject[];
 /**
  * Main entry point that generates TypeScript code from a given API spec.
  */
 export default class ApiGenerator {
-    readonly spec: OpenAPIV3.Document;
+    readonly spec: OpenAPIDocument;
     readonly opts: Opts;
     /** Indicates if the document was converted from an older version of the OpenAPI specification. */
     readonly isConverted: boolean;
-    constructor(spec: OpenAPIV3.Document, opts?: Opts, 
+    constructor(spec: OpenAPIDocument, opts?: Opts, 
     /** Indicates if the document was converted from an older version of the OpenAPI specification. */
     isConverted?: boolean);
     discriminatingSchemas: Set<string>;
@@ -82,8 +91,8 @@ export default class ApiGenerator {
     refsOnlyMode: Map<string, OnlyModes>;
     typeAliases: Record<string, number>;
     reset(): void;
-    resolve<T>(obj: T | OpenAPIV3.ReferenceObject): T;
-    resolveArray<T>(array?: Array<T | OpenAPIV3.ReferenceObject>): T[];
+    resolve<T>(obj: T | OpenAPIReferenceObject): T;
+    resolveArray<T>(array?: Array<T | OpenAPIReferenceObject>): T[];
     skip(tags?: string[]): boolean;
     findAvailableRef(ref: string): string;
     getUniqueAlias(name: string): string;
@@ -91,19 +100,19 @@ export default class ApiGenerator {
     /**
      * Create a type alias for the schema referenced by the given ReferenceObject
      */
-    getRefAlias(obj: OpenAPIV3.ReferenceObject, onlyMode?: OnlyMode, ignoreDiscriminator?: boolean): ts.TypeNode;
-    getUnionType(variants: (OpenAPIV3.ReferenceObject | SchemaObject)[], discriminator?: OpenAPIV3.DiscriminatorObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
+    getRefAlias(obj: OpenAPIReferenceObject, onlyMode?: OnlyMode, ignoreDiscriminator?: boolean): ts.TypeNode;
+    getUnionType(variants: (OpenAPIReferenceObject | SchemaObject)[], discriminator?: OpenAPIDiscriminatorObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
     /**
      * Creates a type node from a given schema.
      * Delegates to getBaseTypeFromSchema internally and
      * optionally adds a union with null.
      */
-    getTypeFromSchema(schema?: SchemaObject | OpenAPIV3.ReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
+    getTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
     /**
      * This is the very core of the OpenAPI to TS conversion - it takes a
      * schema and returns the appropriate type.
      */
-    getBaseTypeFromSchema(schema?: SchemaObject | OpenAPIV3.ReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
+    getBaseTypeFromSchema(schema?: SchemaObject | OpenAPIReferenceObject, name?: string, onlyMode?: OnlyMode): ts.TypeNode;
     isTrueEnum(schema: SchemaObject, name?: string): name is string;
     /**
      * Creates literal type (or union) from an array of values
@@ -116,18 +125,18 @@ export default class ApiGenerator {
      * Returns a tuple of booleans; the first one is about readOnly, the second
      * one is about writeOnly.
      */
-    checkSchemaOnlyMode(schema: SchemaObject | OpenAPIV3.ReferenceObject, resolveRefs?: boolean): OnlyModes;
+    checkSchemaOnlyMode(schema: SchemaObject | OpenAPIReferenceObject, resolveRefs?: boolean): OnlyModes;
     /**
      * Recursively creates a type literal with the given props.
      */
     getTypeFromProperties(props: {
-        [prop: string]: SchemaObject | OpenAPIV3.ReferenceObject;
-    }, required?: string[], additionalProperties?: boolean | OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject, onlyMode?: OnlyMode): ts.TypeLiteralNode;
-    getTypeFromResponses(responses: OpenAPIV3.ResponsesObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
-    getTypeFromResponse(resOrRef: OpenAPIV3.ResponseObject | OpenAPIV3.ReferenceObject, onlyMode?: OnlyMode): ts.TypeNode;
-    getResponseType(responses?: OpenAPIV3.ResponsesObject): "json" | "text" | "blob";
-    getSchemaFromContent(content: Record<string, OpenAPIV3.MediaTypeObject>): OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject;
-    getTypeFromParameter(p: OpenAPIV3.ParameterObject): ts.TypeNode;
+        [prop: string]: SchemaObject | OpenAPIReferenceObject;
+    }, required?: string[], additionalProperties?: boolean | OpenAPISchemaObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): ts.TypeLiteralNode;
+    getTypeFromResponses(responses: OpenAPIResponsesObject, onlyMode?: OnlyMode): ts.UnionTypeNode;
+    getTypeFromResponse(resOrRef: OpenAPIResponseObject | OpenAPIReferenceObject, onlyMode?: OnlyMode): ts.TypeNode;
+    getResponseType(responses?: OpenAPIResponsesObject): "json" | "text" | "blob";
+    getSchemaFromContent(content: Record<string, OpenAPIMediaTypeObject>): OpenAPISchemaObject | OpenAPIReferenceObject;
+    getTypeFromParameter(p: OpenAPIParameterObject): ts.TypeNode;
     wrapResult(ex: ts.Expression): ts.Expression;
     /**
      * Does three things:
@@ -138,7 +147,7 @@ export default class ApiGenerator {
      * 3. Make all mappings of discriminating schemas explicit to generate types immediately.
      */
     preprocessComponents(schemas: {
-        [key: string]: OpenAPIV3.ReferenceObject | SchemaObject;
+        [key: string]: OpenAPIReferenceObject | SchemaObject;
     }): void;
     generateApi(): ts.SourceFile;
 }

package/lib/codegen/generate.js

@@ -116,7 +116,9 @@ function getOperationName(verb, path, operationId) {
 }
 exports.getOperationName = getOperationName;
 function isNullable(schema) {
-    return schema && !isReference(schema) && schema.nullable;
+    if (schema && "nullable" in schema)
+        return !isReference(schema) && schema.nullable;
+    return false;
 }
 exports.isNullable = isNullable;
 function isReference(obj) {
@@ -252,6 +254,9 @@ function supportDeepObjects(params) {
     return res;
 }
 exports.supportDeepObjects = supportDeepObjects;
+function isKeyOfKeywordType(key) {
+    return key in cg.keywordType;
+}
 /**
  * Main entry point that generates TypeScript code from a given API spec.
  */
@@ -556,11 +561,23 @@ class ApiGenerator {
             return this.getTypeFromEnum([schema.const]);
         }
         if (schema.type) {
-            // string, boolean, null, number
+            // string, boolean, null, number, array
+            if (Array.isArray(schema.type)) {
+                return typescript_1.factory.createUnionTypeNode(schema.type.map((type) => {
+                    if (type === "null")
+                        return cg.keywordType.null;
+                    if (type === "integer")
+                        return cg.keywordType.number;
+                    if (isKeyOfKeywordType(type))
+                        return cg.keywordType[type];
+                    return cg.keywordType.any;
+                }));
+            }
             if (schema.type === "integer")
                 return cg.keywordType.number;
-            if (schema.type in cg.keywordType)
+            if (isKeyOfKeywordType(schema.type))
                 return cg.keywordType[schema.type];
+            return cg.keywordType.any;
         }
         return cg.keywordType.any;
     }
@@ -663,7 +680,7 @@ class ApiGenerator {
             let readOnly = (_a = schema.readOnly) !== null && _a !== void 0 ? _a : false;
             let writeOnly = (_b = schema.writeOnly) !== null && _b !== void 0 ? _b : false;
             const subSchemas = [];
-            if ("items" in schema) {
+            if ("items" in schema && schema.items) {
                 subSchemas.push(schema.items);
             }
             else {
@@ -877,185 +894,188 @@ class ApiGenerator {
         const functions = [];
         // Keep track of names to detect duplicates
         const names = {};
-        Object.keys(this.spec.paths).forEach((path) => {
-            const item = this.spec.paths[path];
-            if (!item) {
-                return;
-            }
-            Object.keys(this.resolve(item)).forEach((verb) => {
-                var _a;
-                const method = verb.toUpperCase();
-                // skip summary/description/parameters etc...
-                if (!exports.verbs.includes(method))
+        if (this.spec.paths) {
+            Object.keys(this.spec.paths).forEach((path) => {
+                if (!this.spec.paths)
                     return;
-                const op = item[verb];
-                const { operationId, requestBody, responses, summary, description, tags, } = op;
-                if (this.skip(tags)) {
+                const item = this.spec.paths[path];
+                if (!item) {
                     return;
                 }
-                let name = getOperationName(verb, path, operationId);
-                const count = (names[name] = (names[name] || 0) + 1);
-                if (count > 1) {
-                    // The name is already taken, which means that the spec is probably
-                    // invalid as operationIds must be unique. Since this is quite common
-                    // nevertheless we append a counter:
-                    name += count;
-                }
-                // merge item and 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);
+                Object.keys(this.resolve(item)).forEach((verb) => {
+                    var _a;
+                    const method = verb.toUpperCase();
+                    // skip summary/description/parameters etc...
+                    if (!exports.verbs.includes(method))
+                        return;
+                    const op = item[verb];
+                    const { operationId, requestBody, responses, summary, description, tags, } = op;
+                    if (this.skip(tags)) {
+                        return;
                     }
-                }
-                // expand older OpenAPI parameters into deepObject style where needed
-                const parameters = this.isConverted
-                    ? supportDeepObjects(resolvedParameters)
-                    : resolvedParameters;
-                // convert parameter names to argument names ...
-                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;
-                };
-                const methodParams = [];
-                let body = undefined;
-                let bodyVar = undefined;
-                switch ((_a = this.opts.argumentStyle) !== null && _a !== void 0 ? _a : "positional") {
-                    case "positional":
-                        // split into required/optional
-                        const [required, optional] = lodash_1.default.partition(parameters, "required");
-                        // build the method signature - first all the required parameters
-                        const requiredParams = required.map((p) => cg.createParameter(getArgName(this.resolve(p)), {
-                            type: this.getTypeFromParameter(p),
-                        }));
-                        methodParams.push(...requiredParams);
-                        // add body if present
-                        if (requestBody) {
-                            body = this.resolve(requestBody);
-                            const schema = this.getSchemaFromContent(body.content);
-                            const type = this.getTypeFromSchema(schema, undefined, "writeOnly");
-                            bodyVar = toIdentifier(type.name || getReferenceName(schema) || "body");
-                            methodParams.push(cg.createParameter(bodyVar, {
-                                type,
-                                questionToken: !body.required,
-                            }));
+                    let name = getOperationName(verb, path, operationId);
+                    const count = (names[name] = (names[name] || 0) + 1);
+                    if (count > 1) {
+                        // The name is already taken, which means that the spec is probably
+                        // invalid as operationIds must be unique. Since this is quite common
+                        // nevertheless we append a counter:
+                        name += count;
+                    }
+                    // merge item and 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);
                         }
-                        // add an object with all optional parameters
-                        if (optional.length) {
-                            methodParams.push(cg.createParameter(cg.createObjectBinding(optional
-                                .map((param) => this.resolve(param))
-                                .map((param) => ({ name: getArgName(param) }))), {
-                                initializer: typescript_1.factory.createObjectLiteralExpression(),
-                                type: typescript_1.factory.createTypeLiteralNode(optional.map((p) => cg.createPropertySignature({
-                                    name: getArgName(this.resolve(p)),
-                                    questionToken: true,
-                                    type: this.getTypeFromParameter(p),
-                                }))),
+                    }
+                    // expand older OpenAPI parameters into deepObject style where needed
+                    const parameters = this.isConverted
+                        ? supportDeepObjects(resolvedParameters)
+                        : resolvedParameters;
+                    // convert parameter names to argument names ...
+                    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;
+                    };
+                    const methodParams = [];
+                    let body = undefined;
+                    let bodyVar = undefined;
+                    switch ((_a = this.opts.argumentStyle) !== null && _a !== void 0 ? _a : "positional") {
+                        case "positional":
+                            // split into required/optional
+                            const [required, optional] = lodash_1.default.partition(parameters, "required");
+                            // build the method signature - first all the required parameters
+                            const requiredParams = required.map((p) => cg.createParameter(getArgName(this.resolve(p)), {
+                                type: this.getTypeFromParameter(p),
                             }));
-                        }
-                        break;
-                    case "object":
-                        // build the method signature - first all the required/optional parameters
-                        const paramMembers = parameters.map((p) => cg.createPropertySignature({
-                            name: getArgName(this.resolve(p)),
-                            questionToken: !p.required,
-                            type: this.getTypeFromParameter(p),
-                        }));
-                        // add body if present
-                        if (requestBody) {
-                            body = this.resolve(requestBody);
-                            const schema = this.getSchemaFromContent(body.content);
-                            const type = this.getTypeFromSchema(schema, undefined, "writeOnly");
-                            bodyVar = toIdentifier(type.name || getReferenceName(schema) || "body");
-                            paramMembers.push(cg.createPropertySignature({
-                                name: bodyVar,
-                                questionToken: !body.required,
-                                type,
+                            methodParams.push(...requiredParams);
+                            // add body if present
+                            if (requestBody) {
+                                body = this.resolve(requestBody);
+                                const schema = this.getSchemaFromContent(body.content);
+                                const type = this.getTypeFromSchema(schema, undefined, "writeOnly");
+                                bodyVar = toIdentifier(type.name || getReferenceName(schema) || "body");
+                                methodParams.push(cg.createParameter(bodyVar, {
+                                    type,
+                                    questionToken: !body.required,
+                                }));
+                            }
+                            // add an object with all optional parameters
+                            if (optional.length) {
+                                methodParams.push(cg.createParameter(cg.createObjectBinding(optional
+                                    .map((param) => this.resolve(param))
+                                    .map((param) => ({ name: getArgName(param) }))), {
+                                    initializer: typescript_1.factory.createObjectLiteralExpression(),
+                                    type: typescript_1.factory.createTypeLiteralNode(optional.map((p) => cg.createPropertySignature({
+                                        name: getArgName(this.resolve(p)),
+                                        questionToken: true,
+                                        type: this.getTypeFromParameter(p),
+                                    }))),
+                                }));
+                            }
+                            break;
+                        case "object":
+                            // build the method signature - first all the required/optional parameters
+                            const paramMembers = parameters.map((p) => cg.createPropertySignature({
+                                name: getArgName(this.resolve(p)),
+                                questionToken: !p.required,
+                                type: this.getTypeFromParameter(p),
+                            }));
+                            // add body if present
+                            if (requestBody) {
+                                body = this.resolve(requestBody);
+                                const schema = this.getSchemaFromContent(body.content);
+                                const type = this.getTypeFromSchema(schema, undefined, "writeOnly");
+                                bodyVar = toIdentifier(type.name || getReferenceName(schema) || "body");
+                                paramMembers.push(cg.createPropertySignature({
+                                    name: bodyVar,
+                                    questionToken: !body.required,
+                                    type,
+                                }));
+                            }
+                            // if there's no params, leave methodParams as is and prevent empty object argument generation
+                            if (paramMembers.length === 0) {
+                                break;
+                            }
+                            methodParams.push(cg.createParameter(cg.createObjectBinding([
+                                ...parameters
+                                    .map((param) => this.resolve(param))
+                                    .map((param) => ({ name: getArgName(param) })),
+                                ...(bodyVar ? [{ name: bodyVar }] : []),
+                            ]), {
+                                type: typescript_1.factory.createTypeLiteralNode(paramMembers),
                             }));
-                        }
-                        // if there's no params, leave methodParams as is and prevent empty object argument generation
-                        if (paramMembers.length === 0) {
                             break;
-                        }
-                        methodParams.push(cg.createParameter(cg.createObjectBinding([
-                            ...parameters
-                                .map((param) => this.resolve(param))
-                                .map((param) => ({ name: getArgName(param) })),
-                            ...(bodyVar ? [{ name: bodyVar }] : []),
-                        ]), {
-                            type: typescript_1.factory.createTypeLiteralNode(paramMembers),
-                        }));
-                        break;
-                }
-                // add oazapfts options
-                methodParams.push(cg.createParameter("opts", {
-                    type: typescript_1.factory.createTypeReferenceNode("Oazapfts.RequestOpts", undefined),
-                    questionToken: true,
-                }));
-                // 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");
-                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, getArgName(p)])),
-                        ]);
+                    }
+                    // add oazapfts options
+                    methodParams.push(cg.createParameter("opts", {
+                        type: typescript_1.factory.createTypeReferenceNode("Oazapfts.RequestOpts", undefined),
+                        questionToken: true,
                     }));
-                }
-                const url = createUrlExpression(path, qs);
-                const init = [
-                    typescript_1.factory.createSpreadAssignment(typescript_1.factory.createIdentifier("opts")),
-                ];
-                if (method !== "GET") {
-                    init.push(typescript_1.factory.createPropertyAssignment("method", typescript_1.factory.createStringLiteral(method)));
-                }
-                if (bodyVar) {
-                    init.push(cg.createPropertyAssignment("body", typescript_1.factory.createIdentifier(bodyVar)));
-                }
-                if (header.length) {
-                    init.push(typescript_1.factory.createPropertyAssignment("headers", callOazapftsFunction("mergeHeaders", [
-                        typescript_1.factory.createPropertyAccessChain(typescript_1.factory.createIdentifier("opts"), typescript_1.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), "headers"),
-                        typescript_1.factory.createObjectLiteralExpression([
-                            ...header.map((param) => cg.createPropertyAssignment(param.name, typescript_1.factory.createIdentifier(getArgName(param)))),
-                        ], true),
-                    ])));
-                }
-                const args = [url];
-                if (init.length) {
-                    const formatter = getBodyFormatter(body); // json, form, multipart
-                    const initObj = typescript_1.factory.createObjectLiteralExpression(init, true);
-                    args.push(formatter ? callOazapftsFunction(formatter, [initObj]) : initObj);
-                }
-                functions.push(cg.addComment(cg.createFunctionDeclaration(name, {
-                    modifiers: [cg.modifier.export],
-                }, methodParams, cg.block(typescript_1.factory.createReturnStatement(this.wrapResult(callOazapftsFunction({
-                    json: "fetchJson",
-                    text: "fetchText",
-                    blob: "fetchBlob",
-                }[returnType], args, returnType === "json" || returnType === "blob"
-                    ? [
-                        this.getTypeFromResponses(responses, "readOnly") ||
-                            typescript_1.default.SyntaxKind.AnyKeyword,
-                    ]
-                    : undefined))))), summary || description));
+                    // 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");
+                    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, getArgName(p)])),
+                            ]);
+                        }));
+                    }
+                    const url = createUrlExpression(path, qs);
+                    const init = [
+                        typescript_1.factory.createSpreadAssignment(typescript_1.factory.createIdentifier("opts")),
+                    ];
+                    if (method !== "GET") {
+                        init.push(typescript_1.factory.createPropertyAssignment("method", typescript_1.factory.createStringLiteral(method)));
+                    }
+                    if (bodyVar) {
+                        init.push(cg.createPropertyAssignment("body", typescript_1.factory.createIdentifier(bodyVar)));
+                    }
+                    if (header.length) {
+                        init.push(typescript_1.factory.createPropertyAssignment("headers", callOazapftsFunction("mergeHeaders", [
+                            typescript_1.factory.createPropertyAccessChain(typescript_1.factory.createIdentifier("opts"), typescript_1.factory.createToken(typescript_1.default.SyntaxKind.QuestionDotToken), "headers"),
+                            typescript_1.factory.createObjectLiteralExpression([
+                                ...header.map((param) => cg.createPropertyAssignment(param.name, typescript_1.factory.createIdentifier(getArgName(param)))),
+                            ], true),
+                        ])));
+                    }
+                    const args = [url];
+                    if (init.length) {
+                        const formatter = getBodyFormatter(body); // json, form, multipart
+                        const initObj = typescript_1.factory.createObjectLiteralExpression(init, true);
+                        args.push(formatter ? callOazapftsFunction(formatter, [initObj]) : initObj);
+                    }
+                    functions.push(cg.addComment(cg.createFunctionDeclaration(name, {
+                        modifiers: [cg.modifier.export],
+                    }, methodParams, cg.block(typescript_1.factory.createReturnStatement(this.wrapResult(callOazapftsFunction({
+                        json: "fetchJson",
+                        text: "fetchText",
+                        blob: "fetchBlob",
+                    }[returnType], args, returnType === "json" || returnType === "blob"
+                        ? [
+                            this.getTypeFromResponses(responses, "readOnly") || typescript_1.default.SyntaxKind.AnyKeyword,
+                        ]
+                        : undefined))))), summary || description));
+                });
             });
-        });
+        }
         Object.assign(stub, {
             statements: cg.appendNodes(stub.statements, ...[...this.aliases, ...functions], ...this.enumAliases),
         });