@mittwald/api-code-generator 0.0.0-development-f25b020-20260331 → 3.1.1

package/README.md

@@ -1,73 +1 @@
 Common code base used by `@mittwald/api-client-*` package.
-
-## CLI
-
-Use the CLI commands provided by this package to build your API client and
-validate the OpenAPI-Spec:
-
-```shell
-acg validate spec/openapi.json
-acg generate --name MittwaldAPIV2 spec/openapi.json src/generated --optionalHeader x-access-token
-```
-
-## TypeScript API
-
-If you need to generate the client in code, you can use the TypeScript API
-demonstrated in this template:
-
-```typescript
-import * as path from "path";
-import { UniversalContentLoader } from "@mittwald/api-code-generator/js";
-import { UniversalFileLoader } from "@mittwald/api-code-generator/js";
-import { OpenApiSpec } from "@mittwald/api-code-generator/js";
-import { CodeGenerationModel } from "@mittwald/api-code-generator/js";
-import { prepareTypeScriptOutput } from "@mittwald/api-code-generator/js";
-import { writeIfChangedAsync } from "@mittwald/api-code-generator/js";
-
-const name = "MittwaldAPIV2";
-const inout = `${process.cwd()}/spec/openapi.json`;
-const output = `${process.cwd()}/src/generated`;
-
-// Loading OpenAPI spec
-const loader = new UniversalContentLoader(new UniversalFileLoader(input));
-const openApiDoc = await loader.load();
-
-// Parsing OpenAPI spec
-const spec = await OpenApiSpec.parse(openApiDoc, {
-  skipValidation: flags.skipValidation,
-});
-
-// Building transformation model
-const model = CodeGenerationModel.fromDoc(name, spec.document);
-
-// Generating descriptors
-const descriptorsFileContent = model.paths.compileDescriptors();
-await writeIfChangedAsync(
-  path.join(output, "descriptors.ts"),
-  await prepareTypeScriptOutput(descriptorsFileContent),
-);
-
-// Generating types
-const typesFileContent = await model.compileTypes({
-  rootNamespace: flags.name,
-  optionalHeaders: ["x-access-token"],
-});
-await writeIfChangedAsync(
-  path.join(output, "types.ts"),
-  await prepareTypeScriptOutput(typesFileContent),
-);
-
-// Generating client
-const clientFileContent = model.paths.compileClient();
-await writeIfChangedAsync(
-  path.join(output, "client.ts"),
-  await prepareTypeScriptOutput(clientFileContent),
-);
-
-// if needed: Generating React client
-const reactClientFileContent = model.paths.compileReactClient();
-await writeIfChangedAsync(
-  path.join(output, "client-react.ts"),
-  await prepareTypeScriptOutput(reactClientFileContent),
-);
-```

package/dist/{types/commands → commands}/generate/index.d.ts

@@ -4,7 +4,7 @@ export default class Generate extends Command {
     static flags: {
         skipValidation: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
         name: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
-        optionalHeader: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        optionalHeader: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string[], import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     static args: {
         input: import("@oclif/core/lib/interfaces/parser.js").Arg<string, {

package/dist/{esm/commands → commands}/generate/index.js

@@ -2,10 +2,10 @@ import { Args, Command, Flags, ux } from "@oclif/core";
 import { UniversalContentLoader } from "../../loading/UniversalContentLoader.js";
 import { OpenApiSpec } from "../../openapi/OpenApiSpec.js";
 import { CodeGenerationModel } from "../../generation/model/CodeGenerationModel.js";
+import jetpack from "fs-jetpack";
 import * as path from "path";
 import { prepareTypeScriptOutput } from "../../generation/prepareTypeScriptOutput.js";
 import { UniversalFileLoader } from "../../loading/UniversalFileLoader.js";
-import { writeIfChangedAsync } from "../../lib/writeIfChangedAsync.js";
 export default class Generate extends Command {
     static description = "Generate code from the provided OpenAPI spec.";
     static flags = {
@@ -49,22 +49,18 @@ export default class Generate extends Command {
         ux.action.stop();
         ux.action.start("Generating descriptors");
         const descriptorsFileContent = model.paths.compileDescriptors();
-        await writeIfChangedAsync(path.join(args.output, "descriptors.ts"), await prepareTypeScriptOutput(descriptorsFileContent));
+        await jetpack.writeAsync(path.join(args.output, "descriptors.ts"), prepareTypeScriptOutput(descriptorsFileContent));
         ux.action.stop();
         ux.action.start("Generating types");
         const typesFileContent = await model.compileTypes({
             rootNamespace: flags.name,
             optionalHeaders: flags.optionalHeader,
         });
-        await writeIfChangedAsync(path.join(args.output, "types.ts"), await prepareTypeScriptOutput(typesFileContent));
+        await jetpack.writeAsync(path.join(args.output, "types.ts"), prepareTypeScriptOutput(typesFileContent));
         ux.action.stop();
         ux.action.start("Generating client");
         const clientFileContent = model.paths.compileClient();
-        await writeIfChangedAsync(path.join(args.output, "client.ts"), await prepareTypeScriptOutput(clientFileContent));
-        ux.action.stop();
-        ux.action.start("Generating React client");
-        const reactClientFileContent = model.paths.compileReactClient();
-        await writeIfChangedAsync(path.join(args.output, "client-react.ts"), await prepareTypeScriptOutput(reactClientFileContent));
+        await jetpack.writeAsync(path.join(args.output, "client.ts"), prepareTypeScriptOutput(clientFileContent));
         ux.action.stop();
     }
 }

package/dist/generation/format.d.ts

@@ -0,0 +1 @@
+export declare const format: (ts: string) => string;

package/dist/{esm/generation → generation}/format.js

@@ -1,9 +1,9 @@
 import prettier from "prettier";
 import VError from "verror";
 import { makeError } from "../lib/makeError.js";
-export const format = async (ts) => {
+export const format = (ts) => {
     try {
-        return await prettier.format(ts, {
+        return prettier.format(ts, {
             plugins: [],
             parser: "typescript",
         });

package/dist/{esm/generation → generation}/model/CodeGenerationModel.js

@@ -22,19 +22,10 @@ export class CodeGenerationModel {
         const t = {
             ns: this.rootNamespace.tsType,
             components: await this.components.compileTypes(opts),
-            operationTypes: await this.paths.compileOperationTypes(),
             paths: await this.paths.compileTypes(opts),
         };
         return `\
-      import * as descriptors from "./descriptors.js";
-      import { 
-        InferredRequestData, 
-        InferredResponseData, 
-        HttpStatus 
-      } from "@mittwald/api-client-commons";
-
       export declare module ${t.ns} {
-        ${t.operationTypes}
         ${t.components}
         ${t.paths}
       }

package/dist/{esm/generation/refs → generation/model}/assertNoRefs.js

@@ -1,6 +1,5 @@
-import { isRef } from "./isRef.js";
 export function assertNoRefs(obj) {
-    if (isRef(obj)) {
-        throw new Error(`$ref's are not supported here (ref: ${obj.$ref})`);
+    if ("$ref" in obj) {
+        throw new Error(`$ref's are not supported here (ref: ${obj.$ref}`);
     }
 }

package/dist/{types/generation → generation}/model/components/Components.d.ts

@@ -5,10 +5,6 @@ import { Parameters } from "./Parameters.js";
 import { RequestBodies } from "./RequestBodies.js";
 import { Responses } from "./Responses.js";
 import { SecuritySchemes } from "./SecuritySchemes.js";
-import { OpenAPIV3 } from "openapi-types";
-export type ComponentTypeName = keyof OpenAPIV3.ComponentsObject;
-export type ComponentType<T extends ComponentTypeName> = Required<OpenAPIV3.ComponentsObject>[T][string];
-export type ResolvedComponentType<T extends ComponentTypeName> = Exclude<ComponentType<T>, OpenAPIV3.ReferenceObject>;
 export declare class Components {
     static readonly ns = "Components";
     name: Name;
@@ -17,8 +13,6 @@ export declare class Components {
     parameters: Parameters;
     requestBodies: RequestBodies;
     responses: Responses;
-    model: CodeGenerationModel;
     constructor(model: CodeGenerationModel);
     compileTypes(opts: TypeCompilationOptions): Promise<string>;
-    resolveRef<T extends ComponentTypeName>(componentType: T, obj: ComponentType<T>): ResolvedComponentType<T>;
 }

package/dist/{esm/generation → generation}/model/components/Components.js

@@ -4,9 +4,6 @@ import { Parameters } from "./Parameters.js";
 import { RequestBodies } from "./RequestBodies.js";
 import { Responses } from "./Responses.js";
 import { SecuritySchemes } from "./SecuritySchemes.js";
-import { extractComponentRefName } from "../../refs/extractComponentRefName.js";
-import { assertNoRefs } from "../../refs/assertNoRefs.js";
-import invariant from "invariant";
 export class Components {
     static ns = "Components";
     name;
@@ -15,9 +12,7 @@ export class Components {
     parameters;
     requestBodies;
     responses;
-    model;
     constructor(model) {
-        this.model = model;
         this.name = new Name(Components.ns, model.rootNamespace);
         this.schemas = new Schemas(this, model.doc.components?.schemas ?? {});
         this.securitySchemes = new SecuritySchemes(this, model.doc.components?.securitySchemes ?? {});
@@ -44,18 +39,4 @@ export class Components {
       }
     `;
     }
-    resolveRef(componentType, obj) {
-        if ("$ref" in obj) {
-            invariant(typeof obj.$ref === "string", "PathItemRefs are not supported by now");
-            const refName = extractComponentRefName(obj.$ref, componentType);
-            const resolved = this.model.doc.components?.[componentType]?.[refName];
-            if (resolved === undefined) {
-                throw new Error(`Could not find ref ${obj.$ref} in components.${componentType}`);
-            }
-            assertNoRefs(resolved);
-            return resolved;
-        }
-        assertNoRefs(obj);
-        return obj;
-    }
 }

package/dist/{types/generation → generation}/model/components/Parameters.d.ts

@@ -1,11 +1,13 @@
+import { JSONSchema } from "../global/JSONSchema.js";
 import { Name } from "../global/Name.js";
-import { Components, ComponentType } from "./Components.js";
+import { Components } from "./Components.js";
 import { TypeCompilationOptions } from "../CodeGenerationModel.js";
+import { OpenAPIV3 } from "openapi-types";
 export declare class Parameters {
     static readonly ns = "Parameters";
+    readonly schemas: JSONSchema[];
     readonly components: Components;
     readonly name: Name;
-    readonly parameters: Record<string, ComponentType<"parameters">>;
-    constructor(components: Components, parametersObject: Record<string, ComponentType<"parameters">>);
+    constructor(components: Components, schemas: OpenAPIV3.ComponentsObject["parameters"]);
     compileTypes(opts: TypeCompilationOptions): Promise<string>;
 }

package/dist/{esm/generation → generation}/model/components/Parameters.js

@@ -1,25 +1,20 @@
 import { JSONSchema } from "../global/JSONSchema.js";
 import { Name } from "../global/Name.js";
 import { asyncStringJoin } from "../../asyncStringJoin.js";
-import { assertNoRefs } from "../../refs/assertNoRefs.js";
 export class Parameters {
     static ns = "Parameters";
+    schemas;
     components;
     name;
-    parameters;
-    constructor(components, parametersObject) {
+    constructor(components, schemas) {
         this.components = components;
         this.name = new Name(Parameters.ns, components.name);
-        this.parameters = parametersObject;
+        this.schemas = Object.entries(schemas ?? {}).map(([schemaName, schema]) => new JSONSchema(new Name(schemaName, this.name), schema));
     }
     async compileTypes(opts) {
-        const schemas = Object.entries(this.parameters).map(([name, param]) => {
-            assertNoRefs(param);
-            return new JSONSchema(new Name(name, this.name), param.schema);
-        });
         const t = {
             ns: Parameters.ns,
-            types: await asyncStringJoin(schemas, (schema) => schema.compile(opts)),
+            types: await asyncStringJoin(this.schemas, (schema) => schema.compile(opts)),
         };
         return `\
       namespace ${t.ns} {

package/dist/{esm/generation → generation}/model/components/Responses.js

@@ -1,7 +1,7 @@
 import { Name } from "../global/Name.js";
 import { asyncStringJoin } from "../../asyncStringJoin.js";
 import { Response } from "./Response.js";
-import { assertNoRefs } from "../../refs/assertNoRefs.js";
+import { assertNoRefs } from "../assertNoRefs.js";
 export class Responses {
     static ns = "Responses";
     responses;

package/dist/{esm/generation → generation}/model/components/Schemas.js

@@ -1,7 +1,6 @@
 import { JSONSchema } from "../global/JSONSchema.js";
 import { Name } from "../global/Name.js";
 import { asyncStringJoin } from "../../asyncStringJoin.js";
-import { populateNullableTypes } from "../../populateNullableTypes.js";
 export class Schemas {
     static ns = "Schemas";
     schemas;
@@ -10,9 +9,7 @@ export class Schemas {
     constructor(components, schemas) {
         this.components = components;
         this.name = new Name(Schemas.ns, components.name);
-        this.schemas = Object.entries(schemas ?? {}).map(([schemaName, schema]) => {
-            return new JSONSchema(new Name(schemaName, this.name), populateNullableTypes(schema));
-        });
+        this.schemas = Object.entries(schemas ?? {}).map(([schemaName, schema]) => new JSONSchema(new Name(schemaName, this.name), schema));
     }
     async compileTypes(opts) {
         const t = {

package/dist/{types/generation → generation}/model/components/SecurityScheme.d.ts

@@ -2,10 +2,9 @@ import { OpenAPIV3 } from "openapi-types";
 import { Name } from "../global/Name.js";
 import { SecuritySchemes } from "./SecuritySchemes.js";
 import { JSONSchema } from "../global/JSONSchema.js";
-export type SecuritySchemeType = OpenAPIV3.ApiKeySecurityScheme | OpenAPIV3.HttpSecurityScheme;
 export declare class SecurityScheme {
     readonly in: string;
     readonly name: Name;
     readonly jsonSchema: JSONSchema;
-    constructor(schemes: SecuritySchemes, name: string, doc: SecuritySchemeType);
+    constructor(schemes: SecuritySchemes, name: string, doc: OpenAPIV3.ApiKeySecurityScheme);
 }

package/dist/{esm/generation → generation}/model/components/SecurityScheme.js

@@ -6,17 +6,16 @@ export class SecurityScheme {
     jsonSchema;
     constructor(schemes, name, doc) {
         this.name = new Name(name, schemes.name);
-        this.in = doc.type === "http" ? "header" : doc.in;
-        const propName = doc.type === "http" ? "Authorization" : doc.name;
+        this.in = doc.in;
         this.jsonSchema = new JSONSchema(this.name, {
             type: "object",
             description: doc.description,
             properties: {
-                [propName]: {
+                [doc.name]: {
                     type: "string",
                 },
             },
-            required: [propName],
+            required: [doc.name],
         });
     }
 }

package/dist/{esm/generation → generation}/model/components/SecuritySchemes.js

@@ -1,6 +1,6 @@
 import { Name } from "../global/Name.js";
 import invariant from "invariant";
-import { assertNoRefs } from "../../refs/assertNoRefs.js";
+import { assertNoRefs } from "../assertNoRefs.js";
 import { asyncStringJoin } from "../../asyncStringJoin.js";
 import { SecurityScheme } from "./SecurityScheme.js";
 export class SecuritySchemes {
@@ -13,7 +13,7 @@ export class SecuritySchemes {
         this.name = new Name(SecuritySchemes.ns, components.name);
         Object.values(doc).forEach((scheme) => {
             assertNoRefs(scheme);
-            invariant(scheme.type === "apiKey" || scheme.type === "http", `Security scheme type '${scheme.type}' is not supported (allowed types: 'apiKey', 'http')`);
+            invariant(scheme.type === "apiKey" || scheme.type === "http", `Security scheme type '${scheme.type}' is supported (allowed types: 'apiKey', 'http')`);
         });
         this.schemes = Object.entries(doc).map(([name, scheme]) => new SecurityScheme(this, name, scheme));
     }

package/dist/{types/generation → generation}/model/paths/Paths.d.ts

@@ -11,15 +11,9 @@ export declare class Paths {
     readonly name: Name;
     constructor(model: CodeGenerationModel, paths: OpenAPIV3.PathsObject);
     compileTypes(opts: TypeCompilationOptions): Promise<string>;
-    compileOperationTypes(): Promise<string>;
     compileDescriptors(): string;
-    getFlattenedOperations(httpMethod?: string): Operation[];
-    getGroupedOperationsByTag(httpMethod?: string): Array<[Tag, Operation[]]>;
+    getFlattenedOperations(): Operation[];
+    getGroupedOperationsByTag(): Array<[Tag, Operation[]]>;
     private compileClientMethodsOfTag;
     compileClient(): string;
-    private compileReactClientApiName;
-    private compileReactClientApiBuilderOfTag;
-    private compileReactClientPropertyInitializer;
-    private compileReactClientProperties;
-    compileReactClient(): string;
 }

package/dist/generation/model/paths/Paths.js

@@ -0,0 +1,100 @@
+import { Name } from "../global/Name.js";
+import { Path } from "./Path.js";
+import { asyncStringJoin } from "../../asyncStringJoin.js";
+export class Paths {
+    static ns = "Paths";
+    paths;
+    model;
+    name;
+    constructor(model, paths) {
+        this.model = model;
+        this.name = new Name(Paths.ns, model.rootNamespace);
+        this.paths = Object.entries(paths ?? {})
+            .map(([name, pathDoc]) => {
+            if (pathDoc) {
+                return Path.fromDoc(this, name, pathDoc);
+            }
+        })
+            .filter((p) => !!p);
+    }
+    async compileTypes(opts) {
+        const t = {
+            ns: Paths.ns,
+            types: await asyncStringJoin(this.paths, (path) => path.compileTypes(opts)),
+        };
+        return `\
+      namespace ${t.ns} {
+        ${t.types}
+      }
+    `;
+    }
+    compileDescriptors() {
+        const t = {
+            ns: this.model.rootNamespace.tsType,
+            descriptors: this.getFlattenedOperations()
+                .map((operation) => operation.compileDescriptor())
+                .join("\r\n"),
+        };
+        return `\
+      import { Simplify } from "@mittwald/api-client-commons";
+      import { RequestType } from "@mittwald/api-client-commons";
+      import { Response } from "@mittwald/api-client-commons";
+      import { OpenAPIOperation } from "@mittwald/api-client-commons";    
+      import { ${t.ns} } from "./types.js";
+      
+      ${t.descriptors}
+    `;
+    }
+    getFlattenedOperations() {
+        return this.paths.flatMap((p) => p.operations);
+    }
+    getGroupedOperationsByTag() {
+        const result = new Map();
+        for (const operation of this.getFlattenedOperations()) {
+            for (const tag of operation.tags) {
+                const operationsOfTag = result.get(tag);
+                if (operationsOfTag) {
+                    operationsOfTag.push(operation);
+                }
+                else {
+                    result.set(tag, [operation]);
+                }
+            }
+        }
+        return Array.from(result.entries());
+    }
+    compileClientMethodsOfTag(tag, operations) {
+        const tagName = tag.name.tsVar;
+        const t = {
+            tag: tagName,
+            comment: tag.description,
+            methods: operations
+                .map((op) => op.compileClientMethod(tagName))
+                .join(",\r\n"),
+        };
+        return `\
+      /** ${t.comment} */
+      public readonly ${t.tag} = {
+        ${t.methods}      
+      }
+    `;
+    }
+    compileClient() {
+        const t = {
+            clientClassName: `${this.model.rootNamespace.tsType}Client`,
+            methods: this.getGroupedOperationsByTag()
+                .map(([tag, operations]) => this.compileClientMethodsOfTag(tag, operations))
+                .join("\r\n"),
+        };
+        return `\
+      import * as descriptors from "./descriptors.js";
+      import { ApiClientBase } from "@mittwald/api-client-commons";
+
+      export class ${t.clientClassName} extends ApiClientBase {
+        ${t.methods}
+      }
+      
+      export default ${t.clientClassName}
+    `;
+    }
+}

package/dist/{types/generation → generation}/model/paths/operation/Operation.d.ts

@@ -17,8 +17,5 @@ export declare class Operation {
     static fromDoc(path: Path, httpMethod: string, doc: OpenAPIV3.OperationObject): Operation;
     compileTypes(options: TypeCompilationOptions): Promise<string>;
     compileDescriptor(): string;
-    compileRequestResponseTypes(): string;
-    private getMethodName;
-    compileClientMethod(tag: Tag): string;
-    compileReactClientMethod(tag: Tag): string;
+    compileClientMethod(tagNamePrefix: string): string;
 }

package/dist/{esm/generation → generation}/model/paths/operation/Operation.js

@@ -1,6 +1,7 @@
 import { RequestParameters } from "./RequestParameters.js";
 import { Name } from "../../global/Name.js";
 import { Responses } from "./responses/Responses.js";
+import invariant from "invariant";
 export class Operation {
     path;
     id;
@@ -10,8 +11,8 @@ export class Operation {
     summary;
     tags;
     constructor(path, httpMethod, doc) {
-        const fallbackId = `${httpMethod.raw}-${path.name.raw}`;
-        this.id = new Name(doc.operationId ?? fallbackId);
+        invariant(doc.operationId !== undefined, "Property 'operationId' does not exist in operation object");
+        this.id = new Name(doc.operationId);
         this.path = path;
         this.httpMethod = httpMethod;
         this.parameters = RequestParameters.fromDoc(this, doc);
@@ -59,28 +60,13 @@ export class Operation {
         };
     `;
     }
-    compileRequestResponseTypes() {
-        const t = {
-            ns: this.id.tsType,
-            descriptor: this.id.tsVar,
-        };
-        return `\
-        namespace ${t.ns} {
-          type RequestData = InferredRequestData<typeof descriptors.${t.descriptor}>;
-          type ResponseData<TStatus extends HttpStatus = 200> = InferredResponseData<typeof descriptors.${t.descriptor}, TStatus>;
-        }
-    `;
-    }
-    getMethodName(tag) {
+    compileClientMethod(tagNamePrefix) {
         const methodName = this.id.tsVar;
-        return new Name(methodName.startsWith(tag.name.tsVar)
-            ? methodName.substring(tag.name.tsVar.length)
-            : methodName).tsVar;
-    }
-    compileClientMethod(tag) {
-        const methodName = this.getMethodName(tag);
+        const methodNameWithoutTagPrefix = new Name(methodName.startsWith(tagNamePrefix)
+            ? methodName.substring(tagNamePrefix.length)
+            : methodName);
         const t = {
-            methodName,
+            methodName: methodNameWithoutTagPrefix.tsVar,
             descriptorName: this.id.tsVar,
         };
         return `\
@@ -90,19 +76,4 @@ export class Operation {
       )
     `;
     }
-    compileReactClientMethod(tag) {
-        const methodName = this.getMethodName(tag);
-        const t = {
-            methodName,
-            descriptorName: this.id.tsVar,
-            tag: tag.name.tsVar,
-        };
-        return `\
-      /** ${this.summary} */        
-      ${t.methodName}: new ApiCallAsyncResourceFactory(
-        descriptors.${t.descriptorName},
-        baseClient.${t.tag}.${t.methodName}
-      ).getApiResource
-    `;
-    }
 }

package/dist/{esm/generation → generation}/model/paths/operation/RequestParameters.js

@@ -1,7 +1,6 @@
 import { JSONSchema } from "../../global/JSONSchema.js";
 import { Name } from "../../global/Name.js";
-import { isRef } from "../../../refs/isRef.js";
-import invariant from "invariant";
+import { assertNoRefs } from "../../assertNoRefs.js";
 export class RequestParameters {
     static ns = "Parameters";
     path;
@@ -16,20 +15,16 @@ export class RequestParameters {
         this.header = header;
         this.body = body;
     }
-    static constructParametersSchema(components, name, $in, parameters = [], securitySchemes) {
+    static constructParametersSchema(name, $in, parameters = [], securitySchemes) {
         const properties = {};
         const required = [];
         for (const parameter of parameters) {
-            const resolvedParameter = components.resolveRef("parameters", parameter);
-            if (resolvedParameter.in === $in) {
-                const jsonSchemaObject = isRef(parameter)
-                    ? parameter
-                    : parameter.schema;
-                invariant(!!jsonSchemaObject, `Could not find schema for request parameter ${name.raw}`);
-                properties[resolvedParameter.name] = jsonSchemaObject;
-                if (resolvedParameter.required) {
-                    required.push(resolvedParameter.name);
-                }
+            assertNoRefs(parameter);
+            if (parameter.in === $in && parameter.schema) {
+                properties[parameter.name] = parameter.schema;
+            }
+            if (parameter.required) {
+                required.push(parameter.name);
             }
         }
         const securitySchemesJSONSchemas = securitySchemes
@@ -55,10 +50,9 @@ export class RequestParameters {
             : undefined;
         const requiredSecuritySchemeNames = doc.security?.flatMap((obj) => Object.keys(obj)) ?? [];
         const requiredSecuritySchemes = requiredSecuritySchemeNames.map((name) => operation.path.paths.model.components.securitySchemes.requireScheme(name));
-        const components = operation.path.paths.model.components;
-        const path = RequestParameters.constructParametersSchema(components, name, "path", doc.parameters, requiredSecuritySchemes);
-        const header = RequestParameters.constructParametersSchema(components, name, "header", doc.parameters, requiredSecuritySchemes);
-        const query = RequestParameters.constructParametersSchema(components, name, "query", doc.parameters, requiredSecuritySchemes);
+        const path = RequestParameters.constructParametersSchema(name, "path", doc.parameters, requiredSecuritySchemes);
+        const header = RequestParameters.constructParametersSchema(name, "header", doc.parameters, requiredSecuritySchemes);
+        const query = RequestParameters.constructParametersSchema(name, "query", doc.parameters, requiredSecuritySchemes);
         return new RequestParameters(operation, body, path, query, header);
     }
     async compileTypes(opts) {

package/dist/{types/generation → generation}/prepareTypeScriptOutput.d.ts

@@ -1 +1 @@
-export declare const prepareTypeScriptOutput: (content: string) => Promise<string>;
+export declare const prepareTypeScriptOutput: (content: string) => string;

package/dist/{esm/generation → generation}/prepareTypeScriptOutput.js

@@ -4,7 +4,7 @@ const header = `\
 /* prettier-ignore */
 /* This file is auto-generated with acg (@mittwald/api-code-generator) */
 `;
-export const prepareTypeScriptOutput = async (content) => {
-    const formatted = await format(content);
+export const prepareTypeScriptOutput = (content) => {
+    const formatted = format(content);
     return header + formatted;
 };

package/dist/{types/openapi → openapi}/OpenApiSpec.d.ts

@@ -5,7 +5,6 @@ interface ParserOptions {
 export declare class OpenApiSpec {
     readonly document: OpenAPIV3.Document;
     constructor(document: OpenAPIV3.Document);
-    private static convertToOpenApi;
     static parse(doc: any, opts?: ParserOptions): Promise<OpenApiSpec>;
 }
 export {};