@acrool/rtk-query-codegen-openapi 0.0.1

package/lib/index.js

@@ -0,0 +1,877 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  generateEndpoints: () => generateEndpoints,
+  parseConfig: () => parseConfig
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_module = require("node:module");
+var import_node_path3 = __toESM(require("node:path"));
+
+// src/generate.ts
+var import_node_path2 = __toESM(require("node:path"));
+var import_generate3 = __toESM(require("oazapfts/generate"));
+var import_typescript4 = __toESM(require("typescript"));
+
+// src/utils/factory.ts
+var import_typescript = __toESM(require("typescript"));
+var import_semver = __toESM(require("semver"));
+var originalFactory = import_typescript.default.factory;
+function createImportSpecifier(propertyName, name) {
+  if (import_semver.default.satisfies(import_typescript.default.version, ">= 4.5"))
+    return originalFactory.createImportSpecifier(false, propertyName, name);
+  return originalFactory.createImportSpecifier(propertyName, name);
+}
+function createExportSpecifier(propertyName, name) {
+  if (import_semver.default.satisfies(import_typescript.default.version, ">= 4.5"))
+    return originalFactory.createExportSpecifier(false, propertyName, name);
+  return originalFactory.createExportSpecifier(propertyName, name);
+}
+var factory = {
+  ...originalFactory,
+  createImportSpecifier,
+  createExportSpecifier
+};
+
+// src/codegen.ts
+var import_typescript2 = __toESM(require("typescript"));
+var defaultEndpointBuilder = factory.createIdentifier("build");
+function generateObjectProperties(obj) {
+  return Object.entries(obj).filter(([_, v]) => v).map(([k, v]) => factory.createPropertyAssignment(factory.createIdentifier(k), v));
+}
+function generateImportNode(pkg, namedImports, defaultImportName) {
+  return factory.createImportDeclaration(
+    void 0,
+    factory.createImportClause(
+      false,
+      defaultImportName !== void 0 ? factory.createIdentifier(defaultImportName) : void 0,
+      factory.createNamedImports(
+        Object.entries(namedImports).map(
+          ([propertyName, name]) => factory.createImportSpecifier(
+            name === propertyName ? void 0 : factory.createIdentifier(propertyName),
+            factory.createIdentifier(name)
+          )
+        )
+      )
+    ),
+    factory.createStringLiteral(pkg)
+  );
+}
+function generateCreateApiCall({
+  endpointBuilder = defaultEndpointBuilder,
+  endpointDefinitions,
+  tag
+}) {
+  const injectEndpointsObjectLiteralExpression = factory.createObjectLiteralExpression(
+    generateObjectProperties({
+      endpoints: factory.createArrowFunction(
+        void 0,
+        void 0,
+        [factory.createParameterDeclaration(void 0, void 0, endpointBuilder, void 0, void 0, void 0)],
+        void 0,
+        factory.createToken(import_typescript2.default.SyntaxKind.EqualsGreaterThanToken),
+        factory.createParenthesizedExpression(endpointDefinitions)
+      ),
+      overrideExisting: factory.createFalse()
+    }),
+    true
+  );
+  if (tag) {
+    const enhanceEndpointsObjectLiteralExpression = factory.createObjectLiteralExpression(
+      [factory.createShorthandPropertyAssignment(factory.createIdentifier("addTagTypes"), void 0)],
+      true
+    );
+    return factory.createVariableStatement(
+      void 0,
+      factory.createVariableDeclarationList(
+        [
+          factory.createVariableDeclaration(
+            factory.createIdentifier("injectedRtkApi"),
+            void 0,
+            void 0,
+            factory.createCallExpression(
+              factory.createPropertyAccessExpression(
+                factory.createCallExpression(
+                  factory.createPropertyAccessExpression(
+                    factory.createIdentifier("api"),
+                    factory.createIdentifier("enhanceEndpoints")
+                  ),
+                  void 0,
+                  [enhanceEndpointsObjectLiteralExpression]
+                ),
+                factory.createIdentifier("injectEndpoints")
+              ),
+              void 0,
+              [injectEndpointsObjectLiteralExpression]
+            )
+          )
+        ],
+        import_typescript2.default.NodeFlags.Const
+      )
+    );
+  }
+  return factory.createVariableStatement(
+    void 0,
+    factory.createVariableDeclarationList(
+      [
+        factory.createVariableDeclaration(
+          factory.createIdentifier("injectedRtkApi"),
+          void 0,
+          void 0,
+          factory.createCallExpression(
+            factory.createPropertyAccessExpression(
+              factory.createIdentifier("api"),
+              factory.createIdentifier("injectEndpoints")
+            ),
+            void 0,
+            [injectEndpointsObjectLiteralExpression]
+          )
+        )
+      ],
+      import_typescript2.default.NodeFlags.Const
+    )
+  );
+}
+function generateEndpointDefinition({
+  operationName,
+  type,
+  Response,
+  QueryArg,
+  queryFn,
+  endpointBuilder = defaultEndpointBuilder,
+  extraEndpointsProps,
+  tags
+}) {
+  const objectProperties = generateObjectProperties({ query: queryFn, ...extraEndpointsProps });
+  if (tags.length > 0) {
+    objectProperties.push(
+      factory.createPropertyAssignment(
+        factory.createIdentifier(type === "query" ? "providesTags" : "invalidatesTags"),
+        factory.createArrayLiteralExpression(
+          tags.map((tag) => factory.createStringLiteral(tag)),
+          false
+        )
+      )
+    );
+  }
+  return factory.createPropertyAssignment(
+    factory.createIdentifier(operationName),
+    factory.createCallExpression(
+      factory.createPropertyAccessExpression(endpointBuilder, factory.createIdentifier(type)),
+      [Response, QueryArg],
+      [factory.createObjectLiteralExpression(objectProperties, true)]
+    )
+  );
+}
+function generateTagTypes({ addTagTypes }) {
+  return factory.createVariableStatement(
+    [factory.createModifier(import_typescript2.default.SyntaxKind.ExportKeyword)],
+    factory.createVariableDeclarationList(
+      [
+        factory.createVariableDeclaration(
+          factory.createIdentifier("addTagTypes"),
+          void 0,
+          void 0,
+          factory.createAsExpression(
+            factory.createArrayLiteralExpression(
+              addTagTypes.map((tagType) => factory.createStringLiteral(tagType)),
+              true
+            ),
+            factory.createTypeReferenceNode(factory.createIdentifier("const"), void 0)
+          )
+        )
+      ],
+      import_typescript2.default.NodeFlags.Const
+    )
+  );
+}
+
+// src/generators/react-hooks.ts
+var import_typescript3 = __toESM(require("typescript"));
+var import_generate = require("oazapfts/generate");
+
+// src/utils/capitalize.ts
+function capitalize(str) {
+  return str.replace(str[0], str[0].toUpperCase());
+}
+
+// src/types.ts
+var operationKeys = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+
+// src/utils/getOperationDefinitions.ts
+function getOperationDefinitions(v3Doc) {
+  return Object.entries(v3Doc.paths).flatMap(
+    ([path4, pathItem]) => !pathItem ? [] : Object.entries(pathItem).filter(
+      (arg) => operationKeys.includes(arg[0])
+    ).map(([verb, operation]) => ({
+      path: path4,
+      verb,
+      pathItem,
+      operation
+    }))
+  );
+}
+
+// src/utils/getV3Doc.ts
+var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"));
+var import_swagger2openapi = __toESM(require("swagger2openapi"));
+async function getV3Doc(spec, httpResolverOptions) {
+  const doc = await import_swagger_parser.default.bundle(spec, {
+    resolve: {
+      http: httpResolverOptions
+    }
+  });
+  const isOpenApiV3 = "openapi" in doc && doc.openapi.startsWith("3");
+  if (isOpenApiV3) {
+    return doc;
+  } else {
+    const result = await import_swagger2openapi.default.convertObj(doc, {});
+    return result.openapi;
+  }
+}
+
+// src/utils/isQuery.ts
+function isQuery(verb, overrides) {
+  if (overrides?.type) {
+    return overrides.type === "query";
+  }
+  return verb === "get";
+}
+
+// src/utils/isValidUrl.ts
+function isValidUrl(string) {
+  try {
+    new URL(string);
+  } catch (_) {
+    return false;
+  }
+  return true;
+}
+
+// src/utils/prettier.ts
+var import_node_path = __toESM(require("node:path"));
+var import_prettier = __toESM(require("prettier"));
+var EXTENSION_TO_PARSER = {
+  ts: "typescript",
+  tsx: "typescript",
+  js: "babel",
+  jsx: "babel",
+  "js.flow": "flow",
+  flow: "flow",
+  gql: "graphql",
+  graphql: "graphql",
+  css: "scss",
+  scss: "scss",
+  less: "scss",
+  stylus: "scss",
+  markdown: "markdown",
+  md: "markdown",
+  json: "json"
+};
+async function prettify(filePath, content, prettierConfigFile) {
+  let config = null;
+  let parser = "typescript";
+  if (filePath) {
+    const fileExtension = import_node_path.default.extname(filePath).slice(1);
+    parser = EXTENSION_TO_PARSER[fileExtension];
+    config = await import_prettier.default.resolveConfig(process.cwd(), {
+      useCache: true,
+      editorconfig: !prettierConfigFile,
+      config: prettierConfigFile
+    });
+  } else if (prettierConfigFile) {
+    config = await import_prettier.default.resolveConfig(process.cwd(), {
+      useCache: true,
+      config: prettierConfigFile
+    });
+  }
+  return import_prettier.default.format(content, {
+    parser,
+    ...config
+  });
+}
+
+// src/utils/removeUndefined.ts
+function removeUndefined(t) {
+  return typeof t !== "undefined";
+}
+
+// src/generators/react-hooks.ts
+var createBinding = ({
+  operationDefinition: { verb, path: path4, operation },
+  overrides,
+  isLazy = false
+}) => factory.createBindingElement(
+  void 0,
+  void 0,
+  factory.createIdentifier(
+    `use${isLazy ? "Lazy" : ""}${capitalize((0, import_generate.getOperationName)(verb, path4, operation.operationId))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
+  ),
+  void 0
+);
+var getReactHookName = ({ operationDefinition, endpointOverrides, config }) => {
+  const overrides = getOverrides(operationDefinition, endpointOverrides);
+  const baseParams = {
+    operationDefinition,
+    overrides
+  };
+  const _isQuery = isQuery(operationDefinition.verb, overrides);
+  if (typeof config === "boolean") {
+    return createBinding(baseParams);
+  }
+  if (_isQuery) {
+    return [
+      ...config.queries ? [createBinding(baseParams)] : [],
+      ...config.lazyQueries ? [createBinding({ ...baseParams, isLazy: true })] : []
+    ];
+  }
+  return config.mutations ? createBinding(baseParams) : [];
+};
+var generateReactHooks = ({
+  exportName,
+  operationDefinitions,
+  endpointOverrides,
+  config
+}) => factory.createVariableStatement(
+  [factory.createModifier(import_typescript3.default.SyntaxKind.ExportKeyword)],
+  factory.createVariableDeclarationList(
+    [
+      factory.createVariableDeclaration(
+        factory.createObjectBindingPattern(
+          operationDefinitions.map((operationDefinition) => getReactHookName({ operationDefinition, endpointOverrides, config })).flat()
+        ),
+        void 0,
+        void 0,
+        factory.createIdentifier(exportName)
+      )
+    ],
+    import_typescript3.default.NodeFlags.Const
+  )
+);
+
+// src/generate.ts
+var generatedApiName = "injectedRtkApi";
+var v3DocCache = {};
+var useFetcherImport = generateImportNode("@acrool/react-fetcher", {
+  IUseFetcherArgs: "IUseFetcherArgs"
+});
+function defaultIsDataResponse(code, includeDefault, response, allResponses) {
+  if (includeDefault && code === "default") {
+    return true;
+  }
+  const parsedCode = Number(code);
+  return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
+}
+function getOperationName2({ verb, path: path4, operation }) {
+  return (0, import_generate3.getOperationName)(verb, path4, operation.operationId);
+}
+function getTags({ verb, pathItem }) {
+  const tags = verb && pathItem[verb]?.tags ? pathItem[verb].tags : [];
+  return tags.map((tag) => tag.toString());
+}
+function patternMatches(pattern) {
+  const filters = Array.isArray(pattern) ? pattern : [pattern];
+  return function matcher(operationName) {
+    if (!pattern) return true;
+    return filters.some(
+      (filter) => typeof filter === "string" ? filter === operationName : filter?.test(operationName)
+    );
+  };
+}
+function operationMatches(pattern) {
+  const checkMatch = typeof pattern === "function" ? pattern : patternMatches(pattern);
+  return function matcher(operationDefinition) {
+    if (!pattern) return true;
+    const operationName = getOperationName2(operationDefinition);
+    return checkMatch(operationName, operationDefinition);
+  };
+}
+function getOverrides(operation, endpointOverrides) {
+  return endpointOverrides?.find((override) => operationMatches(override.pattern)(operation));
+}
+async function generateApi(spec, {
+  apiFile,
+  apiImport = "api",
+  exportName = "enhancedApi",
+  argSuffix = "ApiArg",
+  responseSuffix = "ApiResponse",
+  operationNameSuffix = "",
+  hooks = false,
+  tag = false,
+  outputFile,
+  isDataResponse = defaultIsDataResponse,
+  filterEndpoints,
+  endpointOverrides,
+  unionUndefined,
+  encodePathParams = false,
+  encodeQueryParams = false,
+  flattenArg = false,
+  includeDefault = false,
+  useEnumType = false,
+  mergeReadWriteOnly = false,
+  httpResolverOptions
+}) {
+  const v3Doc = v3DocCache[spec] ??= await getV3Doc(spec, httpResolverOptions);
+  const apiGen = new import_generate3.default(v3Doc, {
+    unionUndefined,
+    useEnumType,
+    mergeReadWriteOnly
+  });
+  if (apiGen.spec.components?.schemas) {
+    apiGen.preprocessComponents(apiGen.spec.components.schemas);
+  }
+  const operationDefinitions = getOperationDefinitions(v3Doc).filter(operationMatches(filterEndpoints));
+  const resultFile = import_typescript4.default.createSourceFile(
+    "someFileName.ts",
+    "",
+    import_typescript4.default.ScriptTarget.Latest,
+    /*setParentNodes*/
+    false,
+    import_typescript4.default.ScriptKind.TS
+  );
+  const printer = import_typescript4.default.createPrinter({ newLine: import_typescript4.default.NewLineKind.LineFeed });
+  const interfaces = {};
+  function registerInterface(declaration) {
+    const name = declaration.name.escapedText.toString();
+    if (name in interfaces) {
+      throw new Error(`interface/type alias ${name} already registered`);
+    }
+    interfaces[name] = declaration;
+    return declaration;
+  }
+  if (outputFile) {
+    outputFile = import_node_path2.default.resolve(process.cwd(), outputFile);
+    if (apiFile.startsWith(".")) {
+      apiFile = import_node_path2.default.relative(import_node_path2.default.dirname(outputFile), apiFile);
+      apiFile = apiFile.replace(/\\/g, "/");
+      if (!apiFile.startsWith(".")) apiFile = `./${apiFile}`;
+    }
+  }
+  apiFile = apiFile.replace(/\.[jt]sx?$/, "");
+  return printer.printNode(
+    import_typescript4.default.EmitHint.Unspecified,
+    factory.createSourceFile(
+      [
+        generateImportNode(apiFile, { [apiImport]: "api" }),
+        ...tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : [],
+        generateCreateApiCall({
+          tag,
+          endpointDefinitions: factory.createObjectLiteralExpression(
+            operationDefinitions.map(
+              (operationDefinition) => generateEndpoint({
+                operationDefinition,
+                overrides: getOverrides(operationDefinition, endpointOverrides)
+              })
+            ),
+            true
+          )
+        }),
+        factory.createExportDeclaration(
+          void 0,
+          false,
+          factory.createNamedExports([
+            factory.createExportSpecifier(
+              factory.createIdentifier(generatedApiName),
+              factory.createIdentifier(exportName)
+            )
+          ]),
+          void 0
+        ),
+        ...Object.values(interfaces),
+        ...apiGen.aliases,
+        ...apiGen.enumAliases,
+        ...hooks ? [
+          generateReactHooks({
+            exportName: generatedApiName,
+            operationDefinitions,
+            endpointOverrides,
+            config: hooks
+          })
+        ] : []
+      ],
+      factory.createToken(import_typescript4.default.SyntaxKind.EndOfFileToken),
+      import_typescript4.default.NodeFlags.None
+    ),
+    resultFile
+  );
+  function extractAllTagTypes({ operationDefinitions: operationDefinitions2 }) {
+    const allTagTypes = /* @__PURE__ */ new Set();
+    for (const operationDefinition of operationDefinitions2) {
+      const { verb, pathItem } = operationDefinition;
+      for (const tag2 of getTags({ verb, pathItem })) {
+        allTagTypes.add(tag2);
+      }
+    }
+    return [...allTagTypes];
+  }
+  function generateQueryArgType(operationDefinition) {
+    const {
+      operation: { parameters = [], requestBody }
+    } = operationDefinition;
+    const properties = [];
+    if (requestBody && !(0, import_generate3.isReference)(requestBody)) {
+      const bodySchema = requestBody.content?.["application/json"]?.schema;
+      if (bodySchema) {
+        properties.push(
+          factory.createPropertySignature(
+            void 0,
+            factory.createIdentifier("body"),
+            void 0,
+            factory.createTypeReferenceNode(factory.createIdentifier("any"), void 0)
+          )
+        );
+      }
+    }
+    const queryParams = parameters.filter((p) => !(0, import_generate3.isReference)(p) && p.in === "query");
+    if (queryParams.length > 0) {
+      properties.push(
+        factory.createPropertySignature(
+          void 0,
+          factory.createIdentifier("params"),
+          void 0,
+          factory.createTypeLiteralNode(
+            queryParams.map(
+              (param) => factory.createPropertySignature(
+                void 0,
+                factory.createIdentifier(param.name),
+                factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken),
+                factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.StringKeyword)
+              )
+            )
+          )
+        )
+      );
+    }
+    const headerParams = parameters.filter((p) => !(0, import_generate3.isReference)(p) && p.in === "header");
+    if (headerParams.length > 0) {
+      properties.push(
+        factory.createPropertySignature(
+          void 0,
+          factory.createIdentifier("headers"),
+          void 0,
+          factory.createTypeLiteralNode(
+            headerParams.map(
+              (param) => factory.createPropertySignature(
+                void 0,
+                factory.createIdentifier(param.name),
+                factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken),
+                factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.StringKeyword)
+              )
+            )
+          )
+        )
+      );
+    }
+    return factory.createTypeLiteralNode([
+      factory.createPropertySignature(
+        void 0,
+        factory.createIdentifier("variables"),
+        void 0,
+        factory.createTypeLiteralNode(properties)
+      ),
+      factory.createPropertySignature(
+        void 0,
+        factory.createIdentifier("fetchOptions"),
+        factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken),
+        factory.createTypeReferenceNode(factory.createIdentifier("any"), void 0)
+      )
+    ]);
+  }
+  function generateQueryArgDefinitions(operationDefinition) {
+    const {
+      operation: { parameters = [], requestBody }
+    } = operationDefinition;
+    const queryArg = {};
+    if (requestBody && !(0, import_generate3.isReference)(requestBody)) {
+      const bodySchema = requestBody.content?.["application/json"]?.schema;
+      if (bodySchema) {
+        queryArg["body"] = {
+          name: "body",
+          originalName: "body",
+          type: factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.AnyKeyword),
+          required: true,
+          origin: "body",
+          body: requestBody
+        };
+      }
+    }
+    parameters.filter((p) => !(0, import_generate3.isReference)(p)).forEach((param) => {
+      queryArg[param.name] = {
+        name: param.name,
+        originalName: param.name,
+        type: factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.StringKeyword),
+        required: param.required || false,
+        origin: "param",
+        param
+      };
+    });
+    return queryArg;
+  }
+  function generateEndpoint({
+    operationDefinition,
+    overrides
+  }) {
+    const {
+      verb,
+      path: path4,
+      pathItem,
+      operation,
+      operation: { responses, requestBody }
+    } = operationDefinition;
+    const operationName = getOperationName2({ verb, path: path4, operation });
+    const tags = tag ? getTags({ verb, pathItem }) : [];
+    const isQuery2 = isQuery(verb, overrides);
+    const returnsJson = apiGen.getResponseType(responses) === "json";
+    let ResponseType = factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UnknownKeyword);
+    if (returnsJson) {
+      const returnTypes = Object.entries(responses || {}).map(
+        ([code, response]) => isDataResponse(code, includeDefault, response, responses) && response ? apiGen.getTypeFromResponse(response) : void 0
+      ).filter(removeUndefined);
+      if (returnTypes.length === 1) {
+        ResponseType = returnTypes[0];
+      } else if (returnTypes.length > 1) {
+        ResponseType = factory.createUnionTypeNode(returnTypes);
+      }
+    }
+    const QueryArg = generateQueryArgType(operationDefinition);
+    const wrappedQueryArg = factory.createTypeReferenceNode(factory.createIdentifier("IUseFetcherArgs"), [QueryArg]);
+    const endpointBuilder = factory.createIdentifier("build");
+    const Response = factory.createTypeReferenceNode(
+      factory.createIdentifier(`${capitalize(operationName)}${responseSuffix}`),
+      void 0
+    );
+    const queryArgDefinitions = generateQueryArgDefinitions(operationDefinition);
+    const extraEndpointsProps = isQuery2 ? generateQueryEndpointProps({ operationDefinition }) : generateMutationEndpointProps({ operationDefinition });
+    return generateEndpointDefinition({
+      operationName,
+      type: isQuery2 ? "query" : "mutation",
+      Response,
+      QueryArg: wrappedQueryArg,
+      queryFn: generateQueryFn({
+        operationDefinition,
+        queryArg: queryArgDefinitions,
+        isFlatArg: flattenArg,
+        isQuery: isQuery2,
+        encodePathParams,
+        encodeQueryParams
+      }),
+      extraEndpointsProps,
+      tags,
+      endpointBuilder
+    });
+  }
+  function generateQueryFn({
+    operationDefinition,
+    queryArg,
+    isFlatArg,
+    isQuery: isQuery2,
+    encodePathParams: encodePathParams2,
+    encodeQueryParams: encodeQueryParams2
+  }) {
+    const {
+      verb,
+      path: path4,
+      operation: { parameters = [], requestBody }
+    } = operationDefinition;
+    const bodyParameter = requestBody && !(0, import_generate3.isReference)(requestBody) ? requestBody.content?.["application/json"]?.schema : void 0;
+    const bodyArg = bodyParameter ? queryArg["body"] : void 0;
+    const pathParameters = parameters.filter((p) => !(0, import_generate3.isReference)(p) && p.in === "path").map((param) => ({
+      name: param.name,
+      originalName: param.name,
+      type: factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.StringKeyword),
+      required: param.required,
+      param,
+      origin: "param"
+    }));
+    const queryParameters = parameters.filter((p) => !(0, import_generate3.isReference)(p) && p.in === "query").map((param) => ({
+      name: param.name,
+      originalName: param.name,
+      type: factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.StringKeyword),
+      required: param.required,
+      param,
+      origin: "param"
+    }));
+    const headerParameters = parameters.filter((p) => !(0, import_generate3.isReference)(p) && p.in === "header").map((param) => ({
+      name: param.name,
+      originalName: param.name,
+      type: factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.StringKeyword),
+      required: param.required,
+      param,
+      origin: "param"
+    }));
+    const rootObject = factory.createIdentifier("queryArg");
+    const objectProperties = [
+      factory.createPropertyAssignment(
+        "url",
+        generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams2)
+      ),
+      factory.createPropertyAssignment("method", factory.createStringLiteral(verb.toUpperCase()))
+    ];
+    if (bodyArg) {
+      objectProperties.push(
+        factory.createPropertyAssignment(
+          "body",
+          factory.createPropertyAccessExpression(
+            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("variables")),
+            factory.createIdentifier("body")
+          )
+        )
+      );
+    }
+    if (queryParameters.length) {
+      objectProperties.push(
+        factory.createPropertyAssignment(
+          "params",
+          factory.createPropertyAccessExpression(
+            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("variables")),
+            factory.createIdentifier("params")
+          )
+        )
+      );
+    }
+    if (headerParameters.length) {
+      objectProperties.push(
+        factory.createPropertyAssignment(
+          "headers",
+          factory.createPropertyAccessExpression(
+            factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("variables")),
+            factory.createIdentifier("headers")
+          )
+        )
+      );
+    }
+    objectProperties.push(
+      factory.createPropertyAssignment(
+        "fetchOptions",
+        factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("fetchOptions"))
+      )
+    );
+    return factory.createArrowFunction(
+      void 0,
+      void 0,
+      [factory.createParameterDeclaration(void 0, void 0, rootObject)],
+      void 0,
+      factory.createToken(import_typescript4.default.SyntaxKind.EqualsGreaterThanToken),
+      factory.createParenthesizedExpression(factory.createObjectLiteralExpression(objectProperties, true))
+    );
+  }
+  function generateQueryEndpointProps({}) {
+    return {};
+  }
+  function generateMutationEndpointProps({}) {
+    return {};
+  }
+}
+function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams) {
+  const expressions = [];
+  const head = path4.replace(/\{(.*?)}(.*?)(?=\{|$)/g, (_, expression, literal) => {
+    const param = pathParameters.find((p) => p.originalName === expression);
+    if (!param) {
+      throw new Error(`path parameter ${expression} does not seem to be defined in '${path4}'!`);
+    }
+    expressions.push([param.name, literal]);
+    return "";
+  });
+  return expressions.length ? factory.createTemplateExpression(
+    factory.createTemplateHead(head, head),
+    expressions.map(([prop, literal], index) => {
+      const value = factory.createPropertyAccessExpression(
+        factory.createPropertyAccessExpression(rootObject, factory.createIdentifier("variables")),
+        factory.createIdentifier(prop)
+      );
+      const encodedValue = encodePathParams ? factory.createCallExpression(factory.createIdentifier("encodeURIComponent"), void 0, [
+        factory.createCallExpression(factory.createIdentifier("String"), void 0, [value])
+      ]) : value;
+      return factory.createTemplateSpan(
+        encodedValue,
+        index === expressions.length - 1 ? factory.createTemplateTail(literal, literal) : factory.createTemplateMiddle(literal, literal)
+      );
+    })
+  ) : factory.createStringLiteral(head);
+}
+
+// src/index.ts
+var require2 = (0, import_node_module.createRequire)(__filename);
+async function generateEndpoints(options) {
+  const schemaLocation = options.schemaFile;
+  const schemaAbsPath = isValidUrl(options.schemaFile) ? options.schemaFile : import_node_path3.default.resolve(process.cwd(), schemaLocation);
+  const sourceCode = await enforceOazapftsTsVersion(async () => {
+    return generateApi(schemaAbsPath, options);
+  });
+  const { outputFile, prettierConfigFile } = options;
+  if (outputFile) {
+    import_node_fs.default.writeFileSync(
+      import_node_path3.default.resolve(process.cwd(), outputFile),
+      await prettify(outputFile, sourceCode, prettierConfigFile)
+    );
+  } else {
+    return await prettify(null, sourceCode, prettierConfigFile);
+  }
+}
+function parseConfig(fullConfig) {
+  const outFiles = [];
+  if ("outputFiles" in fullConfig) {
+    const { outputFiles, ...commonConfig } = fullConfig;
+    for (const [outputFile, specificConfig] of Object.entries(outputFiles)) {
+      outFiles.push({
+        ...commonConfig,
+        ...specificConfig,
+        outputFile
+      });
+    }
+  } else {
+    outFiles.push(fullConfig);
+  }
+  return outFiles;
+}
+function enforceOazapftsTsVersion(cb) {
+  const ozTsPath = require2.resolve("typescript", { paths: [require2.resolve("oazapfts")] });
+  const tsPath = require2.resolve("typescript");
+  const originalEntry = require2.cache[ozTsPath];
+  try {
+    require2.cache[ozTsPath] = require2.cache[tsPath];
+    return cb();
+  } finally {
+    if (originalEntry) {
+      require2.cache[ozTsPath] = originalEntry;
+    } else {
+      delete require2.cache[ozTsPath];
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateEndpoints,
+  parseConfig
+});
+//# sourceMappingURL=index.js.map