@zachacious/protoc-gen-connect-vue 1.0.16 → 1.0.18

package/dist/generator.js

@@ -336805,52 +336805,45 @@ var templates = {
   rpc: fs.readFileSync(path.join(templateDir, "rpc.ts.mustache"), "utf-8"),
   index: fs.readFileSync(path.join(templateDir, "index.ts.mustache"), "utf-8")
 };
-function findBestPaginationCandidate(msg, isRequest, depth = 0) {
+function findPaginationPath(msg, isRequest, depth = 0) {
   if (depth > 3)
     return null;
-  let best = null;
+  const reqKeywords = [
+    "pagetoken",
+    "pagenumber",
+    "nextpagetoken",
+    "offset",
+    "cursor"
+  ];
+  const resKeywords = ["nextpagetoken", "nextpage", "nextcursor"];
+  const targets = isRequest ? reqKeywords : resKeywords;
   for (const f of msg.fields) {
-    let currentScore = 0;
-    const name = f.name.toLowerCase().replace(/_/g, "");
-    const reqKeywords = ["token", "page", "offset", "cursor", "start", "skip"];
-    const resKeywords = ["next", "token", "more", "hasmore", "cursor", "total"];
-    const targets = isRequest ? reqKeywords : resKeywords;
-    if (targets.some((t) => name.includes(t)))
-      currentScore += 10;
-    if (name.includes("pagetoken") || name.includes("nextpage"))
-      currentScore += 15;
-    const isString = f.fieldKind === "scalar" && f.scalar === 9;
-    const isNumber = f.fieldKind === "scalar" && [3, 4, 5, 13, 17, 18].includes(f.scalar);
-    if (isString || isNumber) {
-      currentScore += 5;
-      if (!best || currentScore > best.score) {
-        best = {
-          path: [f.name],
-          type: isString ? "string" : "number",
-          score: currentScore
-        };
-      }
-    }
     if (f.fieldKind === "message") {
-      const nested = findBestPaginationCandidate(f.message, isRequest, depth + 1);
-      if (nested) {
-        const nestedScore = nested.score + 12;
-        if (!best || nestedScore > best.score) {
-          best = {
-            path: [f.name, ...nested.path],
-            type: nested.type,
-            score: nestedScore
-          };
-        }
+      const name = f.name.toLowerCase();
+      if (name.includes("page") || name.includes("meta") || name.includes("paging")) {
+        const sub = findPaginationPath(f.message, isRequest, depth + 1);
+        if (sub)
+          return [f.name, ...sub];
       }
     }
   }
-  return best;
+  for (const f of msg.fields) {
+    const normalized = f.name.toLowerCase().replace(/_/g, "");
+    if (targets.some((t) => normalized.includes(t)))
+      return [f.name];
+  }
+  return null;
+}
+function isRepeatedSafe(f) {
+  if (f.fieldKind === "map")
+    return false;
+  return "repeated" in f && f.repeated === true;
 }
 function processService(service) {
   const importMap = new Map;
   const wktImports = new Set;
   const allMessages = new Set;
+  const debugLog = [];
   function track(msg) {
     if (KNOWN_WKT.includes(msg.typeName)) {
       wktImports.add(msg.name);
@@ -336882,20 +336875,28 @@ function processService(service) {
     ];
     const isMutation = mutationVerbs.some((v) => name.startsWith(v));
     const isQuery = isUnary && !isMutation;
-    const reqCandidate = findBestPaginationCandidate(m.input, true);
-    const resCandidate = findBestPaginationCandidate(m.output, false);
-    const isPaginated = isQuery && reqCandidate && resCandidate && reqCandidate.score + resCandidate.score > 25;
+    const reqPath = findPaginationPath(m.input, true);
+    const resPath = findPaginationPath(m.output, false);
+    const hasRepeatedList = m.output.fields.some((f) => isRepeatedSafe(f));
+    const isPaginated = isQuery && hasRepeatedList && !!reqPath && !!resPath;
+    debugLog.push(`Method: ${name}`);
+    debugLog.push(`  isUnary: ${isUnary}, isMutation: ${isMutation} -> isQuery: ${isQuery}`);
+    debugLog.push(`  reqPath: ${reqPath?.join(".")}`);
+    debugLog.push(`  resPath: ${resPath?.join(".")}`);
+    debugLog.push(`  hasRepeatedList: ${hasRepeatedList}`);
+    debugLog.push(`  FINAL: isPaginated = ${isPaginated}`);
+    debugLog.push("---");
     return {
       functionName: name.charAt(0).toLowerCase() + name.slice(1),
       hookName: `use${name}`,
+      infiniteHookName: `use${name}Infinite`,
       resource: name.replace(/^(Get|ListAll|List|Search|Create|Update|Delete|Remove|Patch|Post|Set|Add)/, "") || "Global",
       inputType: m.input.name,
       outputType: m.output.name,
       isQuery,
       isPaginated,
-      reqPath: reqCandidate?.path.join("."),
-      resPath: resCandidate?.path.join("."),
-      pageType: reqCandidate?.type || "string"
+      reqPath: reqPath?.join("."),
+      resPath: resPath?.join(".")
     };
   });
   return {
@@ -336907,12 +336908,14 @@ function processService(service) {
     externalImports: Array.from(importMap.entries()).map(([path2, types2]) => ({
       path: path2,
       types: Array.from(types2)
-    }))
+    })),
+    debugInfo: debugLog.join(`
+`)
   };
 }
 var plugin = createEcmaScriptPlugin({
   name: "protoc-gen-connect-vue",
-  version: "v1.4.0",
+  version: "v1.9.0",
   generateTs: (schema) => {
     const service = schema.files.flatMap((f) => f.services)[0];
     if (!service)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zachacious/protoc-gen-connect-vue",
-  "version": "1.0.16",
+  "version": "1.0.18",
   "description": "Smart TanStack Query & ConnectRPC SDK generator for Vue.js",
   "type": "module",
   "license": "MIT",

package/templates/api.ts.mustache

@@ -58,9 +58,17 @@ export const useApi = () => {
     {{#rpcs}}
     {{functionName}},
     {{hookName}},
+    {{#isPaginated}}
+    {{infiniteHookName}},
+    {{/isPaginated}}
     {{/rpcs}}
     isGlobalLoading,
     queryKeys,
     createEmpty
   };
-};
+};
+
+/*
+--- GENERATOR DEBUG INFO ---
+{{{debugInfo}}}
+*/

package/templates/rpc.ts.mustache

@@ -7,14 +7,29 @@ const {{functionName}} = async (req: {{inputType}}): Promise<APIResponse<{{outpu
   return res;
 };
 
+{{#isQuery}}
 /**
- * Hook: {{hookName}}
+ * Standard Hook: {{hookName}}
  */
 const {{hookName}} = (
-  {{#isQuery}}input: any, options: any = {}{{/isQuery}}
-  {{^isQuery}}options: any = {}{{/isQuery}}
+  input: any, 
+  options: any = {}
+) => {
+  return useQuery({
+    queryKey: queryKeys.{{functionName}}(input),
+    queryFn: () => client.value.{{functionName}}(unref(input)),
+    ...options,
+  });
+};
+
+{{#isPaginated}}
+/**
+ * Infinite Hook: {{infiniteHookName}}
+ */
+const {{infiniteHookName}} = (
+  input: any, 
+  options: any = {}
 ) => {
-  {{#isPaginated}}
   return useInfiniteQuery({
     queryKey: queryKeys.{{functionName}}(input),
     queryFn: async ({ pageParam }) => {
@@ -29,31 +44,28 @@ const {{hookName}} = (
       curr[path[path.length - 1]] = pageParam;
       return client.value.{{functionName}}(req);
     },
-    initialPageParam: options.initialPageParam ?? ( "{{pageType}}" === "string" ? "" : 1 ),
+    initialPageParam: options.initialPageParam ?? "", 
     getNextPageParam: (lastPage: any) => {
       const path = "{{resPath}}".split('.');
       const val = path.reduce((o, i) => o?.[i], lastPage);
-      
-      // If the discovered path is an object (like PageResponse), look for standard keys
       if (typeof val === 'object' && val !== null) {
-        return val.nextPageToken || val.nextPage || val.pageToken || undefined;
+        return val.nextPageToken || val.nextPage || undefined;
       }
       return val || undefined;
     },
     ...options,
   });
-  {{/isPaginated}}
-  
-  {{^isPaginated}}
-  {{#isQuery}}
-  return useQuery({
-    queryKey: queryKeys.{{functionName}}(input),
-    queryFn: () => client.value.{{functionName}}(unref(input)),
-    ...options,
-  });
-  {{/isQuery}}
-  
-  {{^isQuery}}
+};
+{{/isPaginated}}
+{{/isQuery}}
+
+{{^isQuery}}
+/**
+ * Mutation Hook: {{hookName}}
+ */
+const {{hookName}} = (
+  options: any = {}
+) => {
   return useMutation({
     mutationFn: (req: {{inputType}}) => client.value.{{functionName}}(req),
     onSuccess: async (data, variables, context) => {
@@ -62,6 +74,5 @@ const {{hookName}} = (
     },
     ...options,
   });
-  {{/isQuery}}
-  {{/isPaginated}}
-};
+};
+{{/isQuery}}