@yigityalim/next-router-client 1.0.0

package/dist/index.js

@@ -0,0 +1,647 @@
+"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 index_exports = {};
+__export(index_exports, {
+  generateClient: () => generateClient,
+  generateFetchers: () => generateFetchers,
+  generateHooks: () => generateHooks,
+  generateKeys: () => generateKeys,
+  generateTypes: () => generateTypes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/generate-client.ts
+var import_node_fs5 = __toESM(require("fs"));
+var import_node_path5 = __toESM(require("path"));
+
+// src/generators/fetchers.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path = __toESM(require("path"));
+async function generateFetchers(options) {
+  const { openApiPath, outputDir, baseUrl } = options;
+  const spec = JSON.parse(import_node_fs.default.readFileSync(openApiPath, "utf-8"));
+  const routes = parseRoutes(spec);
+  const code = generateFetcherCode(routes, baseUrl);
+  const fetchersPath = import_node_path.default.join(outputDir, "fetchers.ts");
+  import_node_fs.default.writeFileSync(fetchersPath, code);
+}
+function parseRoutes(spec) {
+  const routes = [];
+  for (const [path6, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [method, operation] of Object.entries(pathItem)) {
+      if (!["get", "post", "put", "delete", "patch"].includes(method)) continue;
+      routes.push({
+        path: path6,
+        method: method.toUpperCase(),
+        operationId: operation.operationId || `${method}${path6.replace(/\//g, "_")}`,
+        parameters: operation.parameters || [],
+        requestBody: operation.requestBody,
+        responses: operation.responses || {}
+      });
+    }
+  }
+  return routes;
+}
+function generateFetcherCode(routes, baseUrl) {
+  let code = `/**
+ * This file was auto-generated by route-handler client generator.
+ * Do not make direct changes to this file.
+ */
+
+export interface FetcherOptions {
+  baseUrl?: string;
+  headers?: Record<string, string>;
+}
+
+const defaultOptions: FetcherOptions = {
+  baseUrl: "${baseUrl}",
+};
+
+function buildQueryString(params: Record<string, unknown>): string {
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== null) {
+      searchParams.append(key, String(value));
+    }
+  }
+  return searchParams.toString();
+}
+
+async function fetcher<TData = unknown>(
+  path: string,
+  init?: RequestInit,
+  options?: FetcherOptions,
+): Promise<TData> {
+  const { baseUrl, headers } = { ...defaultOptions, ...options };
+  const url = \`\${baseUrl}\${path}\`;
+
+  const response = await fetch(url, {
+    ...init,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers,
+      ...init?.headers,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(\`HTTP error! status: \${response.status}\`);
+  }
+
+  return response.json();
+}
+
+`;
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const resource = extractResource(route.path);
+    if (!resourceMap.has(resource)) {
+      resourceMap.set(resource, []);
+    }
+    resourceMap.get(resource).push(route);
+  }
+  for (const [resource, resourceRoutes] of resourceMap) {
+    code += `export const ${resource}Fetchers = {
+`;
+    for (const route of resourceRoutes) {
+      code += generateFetcherFunction(route);
+    }
+    code += `};
+
+`;
+  }
+  return code;
+}
+function extractResource(path6) {
+  const parts = path6.split("/").filter(Boolean);
+  const resourcePart = parts.find((p) => !p.startsWith("{") && p !== "v1");
+  return resourcePart || "api";
+}
+function generateFetcherFunction(route) {
+  const { method, path: path6, operationId } = route;
+  const hasPathParams = path6.includes("{");
+  const hasQueryParams = route.parameters?.some((p) => p.in === "query");
+  const hasBody = method !== "GET" && method !== "DELETE";
+  const funcName = operationId.replace(
+    /[A-Z]/g,
+    (m, offset) => offset > 0 ? m : m.toLowerCase()
+  );
+  let params = "";
+  let pathReplacement = path6;
+  let fetchOptions = "";
+  if (hasPathParams) {
+    const pathParams = route.parameters?.filter((p) => p.in === "path") || [];
+    params += pathParams.map((p) => `${p.name}: string`).join(", ");
+    for (const param of pathParams) {
+      pathReplacement = pathReplacement.replace(
+        `{${param.name}}`,
+        `\${${param.name}}`
+      );
+    }
+  }
+  if (hasQueryParams) {
+    if (params) params += ", ";
+    params += "params?: Record<string, unknown>";
+  }
+  if (hasBody) {
+    if (params) params += ", ";
+    params += "body?: unknown";
+    fetchOptions = `, { method: "${method}", body: JSON.stringify(body) }`;
+  } else if (method !== "GET") {
+    fetchOptions = `, { method: "${method}" }`;
+  }
+  let url = `\`${pathReplacement}\``;
+  if (hasQueryParams) {
+    url += ` + (params ? \`?\${buildQueryString(params)}\` : "")`;
+  }
+  return `  ${funcName}: async (${params}) => fetcher(${url}${fetchOptions}),
+`;
+}
+
+// src/generators/hooks.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+async function generateHooks(options) {
+  const { openApiPath, outputDir, library } = options;
+  const spec = JSON.parse(import_node_fs2.default.readFileSync(openApiPath, "utf-8"));
+  const routes = parseRoutes2(spec);
+  const code = library === "react-query" ? generateReactQueryHooks(routes) : generateSWRHooks(routes);
+  const hooksPath = import_node_path2.default.join(outputDir, "hooks.ts");
+  import_node_fs2.default.writeFileSync(hooksPath, code);
+}
+function parseRoutes2(spec) {
+  const routes = [];
+  for (const [path6, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [method, operation] of Object.entries(pathItem)) {
+      if (!["get", "post", "put", "delete", "patch"].includes(method)) continue;
+      routes.push({
+        path: path6,
+        method: method.toUpperCase(),
+        operationId: operation.operationId || `${method}${path6.replace(/\//g, "_")}`,
+        parameters: operation.parameters || [],
+        requestBody: operation.requestBody,
+        responses: operation.responses || {}
+      });
+    }
+  }
+  return routes;
+}
+function generateReactQueryHooks(routes) {
+  let code = `/**
+ * This file was auto-generated by route-handler client generator.
+ * Do not make direct changes to this file.
+ */
+
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import type { UseQueryOptions, UseMutationOptions } from "@tanstack/react-query";
+import * as fetchers from "./fetchers";
+import * as keys from "./keys";
+
+`;
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const resource = extractResource2(route.path);
+    if (!resourceMap.has(resource)) {
+      resourceMap.set(resource, []);
+    }
+    resourceMap.get(resource).push(route);
+  }
+  for (const [resource, resourceRoutes] of resourceMap) {
+    for (const route of resourceRoutes.filter((r) => r.method === "GET")) {
+      code += generateReactQueryHook(resource, route);
+    }
+    for (const route of resourceRoutes.filter((r) => r.method !== "GET")) {
+      code += generateReactMutationHook(resource, route);
+    }
+  }
+  return code;
+}
+function generateReactQueryHook(resource, route) {
+  const isList = !route.path.includes("{");
+  const hookName = isList ? `use${capitalize(resource)}` : `use${capitalize(resource.endsWith("s") ? resource.slice(0, -1) : resource)}`;
+  const keyFactory = isList ? `keys.${resource}Keys.list` : `keys.${resource}Keys.detail`;
+  const fetcherName = route.operationId;
+  const hasQueryParams = route.parameters?.some((p) => p.in === "query");
+  let params = "";
+  let fetcherArgs = "";
+  let keyArgs = "";
+  if (isList && hasQueryParams) {
+    params = "params?: Record<string, unknown>, ";
+    fetcherArgs = "params";
+    keyArgs = "params";
+  } else if (isList) {
+    keyArgs = "undefined";
+  } else if (!isList) {
+    params = "id: string, ";
+    fetcherArgs = "id";
+    keyArgs = "id";
+  }
+  return `export function ${hookName}(${params}options?: Omit<UseQueryOptions, "queryKey" | "queryFn">) {
+  return useQuery({
+    queryKey: ${keyFactory}(${keyArgs}),
+    queryFn: () => fetchers.${resource}Fetchers.${fetcherName}(${fetcherArgs}),
+    ...options,
+  });
+}
+
+`;
+}
+function generateReactMutationHook(resource, route) {
+  const hookName = generateHookName(resource, route);
+  const fetcherName = route.operationId;
+  const pathParams = route.parameters?.filter((p) => p.in === "path") || [];
+  const hasBody = route.method !== "DELETE" && route.method !== "GET";
+  let paramsInterface = "{ ";
+  for (const param of pathParams) {
+    paramsInterface += `${param.name}: string; `;
+  }
+  if (hasBody) {
+    paramsInterface += "body?: unknown; ";
+  }
+  paramsInterface += "}";
+  let destructure = "{ ";
+  let fetcherArgs = "";
+  for (const param of pathParams) {
+    destructure += `${param.name}, `;
+    fetcherArgs += `${param.name}, `;
+  }
+  if (hasBody) {
+    destructure += "body ";
+    fetcherArgs += "body";
+  } else {
+    destructure = destructure.slice(0, -2);
+    fetcherArgs = fetcherArgs.slice(0, -2);
+  }
+  destructure += "}";
+  return `export function ${hookName}(options?: UseMutationOptions<unknown, Error, ${paramsInterface}>) {
+  const queryClient = useQueryClient();
+  
+  return useMutation({
+    mutationFn: (${destructure}) => fetchers.${resource}Fetchers.${fetcherName}(${fetcherArgs}),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: keys.${resource}Keys.all });
+    },
+    ...options,
+  });
+}
+
+`;
+}
+function generateHookName(resource, route) {
+  const singular = resource.endsWith("s") ? resource.slice(0, -1) : resource;
+  switch (route.method) {
+    case "POST":
+      return `useCreate${capitalize(singular)}`;
+    case "PUT":
+    case "PATCH":
+      if (route.path.includes("/public")) {
+        return `useToggle${capitalize(singular)}Visibility`;
+      }
+      return `useUpdate${capitalize(singular)}`;
+    case "DELETE":
+      return `useDelete${capitalize(singular)}`;
+    default:
+      return `use${capitalize(route.operationId)}`;
+  }
+}
+function generateSWRHooks(routes) {
+  let code = `/**
+ * This file was auto-generated by route-handler client generator.
+ * Do not make direct changes to this file.
+ */
+
+import useSWR from "swr";
+import useSWRMutation from "swr/mutation";
+import type { SWRConfiguration } from "swr";
+import * as fetchers from "./fetchers";
+import * as keys from "./keys";
+
+`;
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const resource = extractResource2(route.path);
+    if (!resourceMap.has(resource)) {
+      resourceMap.set(resource, []);
+    }
+    resourceMap.get(resource).push(route);
+  }
+  for (const [resource, resourceRoutes] of resourceMap) {
+    for (const route of resourceRoutes.filter((r) => r.method === "GET")) {
+      code += generateSWRHook(resource, route);
+    }
+    for (const route of resourceRoutes.filter((r) => r.method !== "GET")) {
+      code += generateSWRMutationHook(resource, route);
+    }
+  }
+  return code;
+}
+function generateSWRHook(resource, route) {
+  const isList = !route.path.includes("{");
+  const hookName = isList ? `use${capitalize(resource)}` : `use${capitalize(resource.endsWith("s") ? resource.slice(0, -1) : resource)}`;
+  const keyFactory = isList ? `keys.${resource}Keys.list` : `keys.${resource}Keys.detail`;
+  const fetcherName = route.operationId;
+  const hasQueryParams = route.parameters?.some((p) => p.in === "query");
+  let params = "";
+  let fetcherArgs = "";
+  let keyArgs = "";
+  if (isList && hasQueryParams) {
+    params = "params?: Record<string, unknown>, ";
+    fetcherArgs = "params";
+    keyArgs = "params";
+  } else if (isList) {
+    keyArgs = "undefined";
+  } else if (!isList) {
+    params = "id: string, ";
+    fetcherArgs = "id";
+    keyArgs = "id";
+  }
+  return `export function ${hookName}(${params}config?: SWRConfiguration) {
+  return useSWR(
+    ${keyFactory}(${keyArgs}),
+    () => fetchers.${resource}Fetchers.${fetcherName}(${fetcherArgs}),
+    config
+  );
+}
+
+`;
+}
+function generateSWRMutationHook(resource, route) {
+  const hookName = generateHookName(resource, route);
+  const fetcherName = route.operationId;
+  const pathParams = route.parameters?.filter((p) => p.in === "path") || [];
+  const hasBody = route.method !== "DELETE" && route.method !== "GET";
+  let argType = "{ ";
+  for (const param of pathParams) {
+    argType += `${param.name}: string; `;
+  }
+  if (hasBody) {
+    argType += "body?: unknown; ";
+  }
+  argType += "}";
+  let fetcherArgs = "";
+  for (const param of pathParams) {
+    fetcherArgs += `arg.${param.name}, `;
+  }
+  if (hasBody) {
+    fetcherArgs += "arg.body";
+  } else {
+    fetcherArgs = fetcherArgs.slice(0, -2);
+  }
+  return `export function ${hookName}() {
+  return useSWRMutation(
+    keys.${resource}Keys.all,
+    async (_key, { arg }: { arg: ${argType} }) => 
+      fetchers.${resource}Fetchers.${fetcherName}(${fetcherArgs})
+  );
+}
+
+`;
+}
+function extractResource2(path6) {
+  const parts = path6.split("/").filter(Boolean);
+  const resourcePart = parts.find((p) => !p.startsWith("{") && p !== "v1");
+  return resourcePart || "api";
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/generators/keys.ts
+var import_node_fs3 = __toESM(require("fs"));
+var import_node_path3 = __toESM(require("path"));
+async function generateKeys(options) {
+  const { openApiPath, outputDir } = options;
+  const spec = JSON.parse(import_node_fs3.default.readFileSync(openApiPath, "utf-8"));
+  const routes = parseRoutes3(spec);
+  const code = generateKeysCode(routes);
+  const keysPath = import_node_path3.default.join(outputDir, "keys.ts");
+  import_node_fs3.default.writeFileSync(keysPath, code);
+}
+function parseRoutes3(spec) {
+  const routes = [];
+  for (const [path6, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [method, operation] of Object.entries(pathItem)) {
+      if (!["get", "post", "put", "delete", "patch"].includes(method)) continue;
+      routes.push({
+        path: path6,
+        method: method.toUpperCase(),
+        operationId: operation.operationId || `${method}${path6.replace(/\//g, "_")}`,
+        parameters: operation.parameters || [],
+        requestBody: operation.requestBody,
+        responses: operation.responses || {}
+      });
+    }
+  }
+  return routes;
+}
+function generateKeysCode(routes) {
+  let code = `/**
+ * This file was auto-generated by route-handler client generator.
+ * Do not make direct changes to this file.
+ * 
+ * Query key factories following TanStack Query best practices.
+ * @see https://tkdodo.eu/blog/effective-react-query-keys
+ */
+
+`;
+  const resourceMap = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const resource = extractResource3(route.path);
+    if (!resourceMap.has(resource)) {
+      resourceMap.set(resource, []);
+    }
+    resourceMap.get(resource).push(route);
+  }
+  for (const [resource, resourceRoutes] of resourceMap) {
+    code += `export const ${resource}Keys = {
+`;
+    code += `  all: ["${resource}"] as const,
+`;
+    const listRoutes = resourceRoutes.filter(
+      (r) => !r.path.includes("{") && r.method === "GET"
+    );
+    if (listRoutes.length > 0) {
+      code += `  lists: () => [...${resource}Keys.all, "list"] as const,
+`;
+      code += `  list: (filters?: Record<string, unknown>) => [...${resource}Keys.lists(), filters] as const,
+`;
+    }
+    const detailRoutes = resourceRoutes.filter(
+      (r) => r.path.includes("{") && r.method === "GET"
+    );
+    if (detailRoutes.length > 0) {
+      code += `  details: () => [...${resource}Keys.all, "detail"] as const,
+`;
+      code += `  detail: (id: string) => [...${resource}Keys.details(), id] as const,
+`;
+    }
+    code += `};
+
+`;
+  }
+  return code;
+}
+function extractResource3(path6) {
+  const parts = path6.split("/").filter(Boolean);
+  const resourcePart = parts.find((p) => !p.startsWith("{") && p !== "v1");
+  return resourcePart || "api";
+}
+
+// src/generators/types.ts
+var import_node_fs4 = __toESM(require("fs"));
+var import_node_path4 = __toESM(require("path"));
+var import_openapi_typescript = __toESM(require("openapi-typescript"));
+async function generateTypes(options) {
+  const { openApiPath, outputDir } = options;
+  const ast = await (0, import_openapi_typescript.default)(new URL(`file://${import_node_path4.default.resolve(openApiPath)}`));
+  const output = (0, import_openapi_typescript.astToString)(ast);
+  const header = `/**
+ * This file was auto-generated by route-handler client generator.
+ * Do not make direct changes to this file.
+ */
+
+`;
+  const typesPath = import_node_path4.default.join(outputDir, "types.ts");
+  import_node_fs4.default.writeFileSync(typesPath, header + output);
+}
+
+// src/generate-client.ts
+async function generateClient(options) {
+  const {
+    openApiPath,
+    outputDir = ".next-router/generated",
+    library = "vanilla",
+    baseUrl = "/api/v1"
+  } = options;
+  const resolvedOutputDir = import_node_path5.default.resolve(process.cwd(), outputDir);
+  if (import_node_fs5.default.existsSync(resolvedOutputDir)) {
+    import_node_fs5.default.rmSync(resolvedOutputDir, { recursive: true, force: true });
+  }
+  import_node_fs5.default.mkdirSync(resolvedOutputDir, { recursive: true });
+  console.log(`
+\u{1F4C1} Output directory: ${outputDir}`);
+  console.log(`\u{1F4DA} Client library: ${library}`);
+  console.log(`\u{1F310} Base URL: ${baseUrl}
+`);
+  console.log("\u2699\uFE0F  Generating types...");
+  await generateTypes({ openApiPath, outputDir: resolvedOutputDir });
+  console.log("\u2699\uFE0F  Generating fetchers...");
+  await generateFetchers({
+    openApiPath,
+    outputDir: resolvedOutputDir,
+    baseUrl
+  });
+  console.log("\u2699\uFE0F  Generating query keys...");
+  await generateKeys({ openApiPath, outputDir: resolvedOutputDir });
+  if (library !== "vanilla") {
+    console.log(`\u2699\uFE0F  Generating ${library} hooks...`);
+    await generateHooks({ openApiPath, outputDir: resolvedOutputDir, library });
+  }
+  const indexContent = generateIndexFile(library);
+  import_node_fs5.default.writeFileSync(import_node_path5.default.join(resolvedOutputDir, "index.ts"), indexContent);
+  updateTsConfig(resolvedOutputDir);
+  console.log("\n\u2705 Client generation complete!");
+  console.log(`
+Import from: import { ... } from "next-router/generated"
+`);
+}
+function generateIndexFile(library) {
+  let exports2 = `export * from "./types";
+export * from "./fetchers";
+export * from "./keys";
+`;
+  if (library !== "vanilla") {
+    exports2 += `export * from "./hooks";
+`;
+  }
+  return exports2;
+}
+function updateTsConfig(resolvedOutputDir) {
+  let searchDir = resolvedOutputDir;
+  let tsconfigPath = null;
+  for (let i = 0; i < 5; i++) {
+    searchDir = import_node_path5.default.dirname(searchDir);
+    const candidatePath = import_node_path5.default.join(searchDir, "tsconfig.json");
+    if (import_node_fs5.default.existsSync(candidatePath)) {
+      tsconfigPath = candidatePath;
+      break;
+    }
+  }
+  if (!tsconfigPath) {
+    console.log("\n\u26A0\uFE0F  tsconfig.json not found - skipping path alias setup");
+    console.log(`   Add this to your tsconfig.json manually:`);
+    console.log(`   "paths": { "next-router/generated/*": [".next-router/generated/*"] }
+`);
+    return;
+  }
+  const tsconfigDir = import_node_path5.default.dirname(tsconfigPath);
+  const relativeOutputDir = import_node_path5.default.relative(tsconfigDir, resolvedOutputDir).replace(/\\/g, "/");
+  try {
+    const tsconfigContent = import_node_fs5.default.readFileSync(tsconfigPath, "utf-8");
+    const tsconfig = JSON.parse(tsconfigContent);
+    if (!tsconfig.compilerOptions) {
+      tsconfig.compilerOptions = {};
+    }
+    if (!tsconfig.compilerOptions.paths) {
+      tsconfig.compilerOptions.paths = {};
+    }
+    const pathKey = `next-router/generated/*`;
+    const pathValue = [`${relativeOutputDir}/*`];
+    const existingPath = tsconfig.compilerOptions.paths[pathKey];
+    if (JSON.stringify(existingPath) !== JSON.stringify(pathValue)) {
+      tsconfig.compilerOptions.paths[pathKey] = pathValue;
+      import_node_fs5.default.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+      console.log(`
+\u2705 Updated ${import_node_path5.default.basename(import_node_path5.default.dirname(tsconfigPath))}/${import_node_path5.default.basename(tsconfigPath)} with path alias:`);
+      console.log(`   "${pathKey}": ["${pathValue[0]}"]`);
+    } else {
+      console.log(`
+\u2713 Path alias already configured in ${import_node_path5.default.basename(import_node_path5.default.dirname(tsconfigPath))}/${import_node_path5.default.basename(tsconfigPath)}`);
+    }
+  } catch (error) {
+    console.log(`
+\u26A0\uFE0F  Could not update tsconfig.json automatically`);
+    console.log(`   Add this to your tsconfig.json manually:`);
+    console.log(
+      `   "paths": { "next-router/generated/*": ["${relativeOutputDir}/*"] }
+`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateClient,
+  generateFetchers,
+  generateHooks,
+  generateKeys,
+  generateTypes
+});
+//# sourceMappingURL=index.js.map