@zachacious/protoc-gen-connect-vue 1.0.8 → 1.0.10

package/dist/generator.js

@@ -336793,96 +336793,100 @@ var mustache_default = mustache;
 
 // src/generator.ts
 var METHOD_KIND_UNARY = 1;
-var KNOWN_TYPES = {
-  "google.protobuf.Empty": "Empty",
-  "google.protobuf.Timestamp": "Timestamp",
-  "google.protobuf.Duration": "Duration"
-};
+var KNOWN_WKT = [
+  "google.protobuf.Empty",
+  "google.protobuf.Timestamp",
+  "google.protobuf.Duration"
+];
 var currentDir = new URL(".", import.meta.url).pathname;
 var templateDir = path.join(currentDir, "..", "templates");
-var clientTemplate = fs.readFileSync(path.join(templateDir, "client.ts.mustache"), "utf-8");
-var apiTemplate = fs.readFileSync(path.join(templateDir, "api.ts.mustache"), "utf-8");
-var rpcPartial = fs.readFileSync(path.join(templateDir, "rpc.ts.mustache"), "utf-8");
-var indexTemplate = fs.readFileSync(path.join(templateDir, "index.ts.mustache"), "utf-8");
-var partials = { rpc: rpcPartial };
-function isPaginatedDeep(message, visited = new Set) {
-  if (visited.has(message.typeName))
-    return false;
-  visited.add(message.typeName);
-  const pagingKeys = ["page", "offset", "cursor", "limit", "pagesize", "pagenumber"];
-  for (const field of message.fields) {
-    if (pagingKeys.includes(field.name.toLowerCase()))
-      return true;
-    if (field.fieldKind === "message") {
-      if (isPaginatedDeep(field.message, visited))
-        return true;
-    }
-  }
-  return false;
-}
-function processType(typeDesc, serviceFile, wktImports, localImports, externalImports) {
-  const fullTypeName = typeDesc.typeName;
-  const baseName = typeDesc.name;
-  if (KNOWN_TYPES[fullTypeName]) {
-    wktImports.add(KNOWN_TYPES[fullTypeName]);
-    return KNOWN_TYPES[fullTypeName];
-  }
-  const importPath = `./gen/${typeDesc.file.name.replace(".proto", "_pb")}`;
-  if (typeDesc.file.name === serviceFile.name) {
-    localImports.add(baseName);
-  } else {
-    if (!externalImports.has(importPath)) {
-      externalImports.set(importPath, new Set);
-    }
-    externalImports.get(importPath).add(baseName);
+var templates = {
+  client: fs.readFileSync(path.join(templateDir, "client.ts.mustache"), "utf-8"),
+  api: fs.readFileSync(path.join(templateDir, "api.ts.mustache"), "utf-8"),
+  rpc: fs.readFileSync(path.join(templateDir, "rpc.ts.mustache"), "utf-8"),
+  index: fs.readFileSync(path.join(templateDir, "index.ts.mustache"), "utf-8")
+};
+function findPath(msg, targets, depth = 0) {
+  if (depth > 4)
+    return null;
+  for (const f of msg.fields) {
+    if (targets.includes(f.name.toLowerCase()))
+      return [f.name];
   }
-  return baseName;
-}
-function collectAllMessages(message, serviceFile, wktImports, localImports, externalImports, seen = new Set) {
-  if (seen.has(message.typeName))
-    return;
-  seen.add(message.typeName);
-  processType(message, serviceFile, wktImports, localImports, externalImports);
-  for (const field of message.fields) {
-    if (field.fieldKind === "message") {
-      collectAllMessages(field.message, serviceFile, wktImports, localImports, externalImports, seen);
+  for (const f of msg.fields) {
+    if (f.fieldKind === "message") {
+      const p = findPath(f.message, targets, depth + 1);
+      if (p)
+        return [f.name, ...p];
     }
   }
+  return null;
 }
-function processService(service, protoPbFile) {
-  const rpcs = [];
+function processService(service) {
+  const importMap = new Map;
   const wktImports = new Set;
-  const localImports = new Set;
-  const externalImports = new Map;
-  const allSeenMessages = new Set;
-  for (const method of service.methods) {
-    collectAllMessages(method.input, service.file, wktImports, localImports, externalImports, allSeenMessages);
-    collectAllMessages(method.output, service.file, wktImports, localImports, externalImports, allSeenMessages);
-    const camelName = method.name.charAt(0).toLowerCase() + method.name.slice(1);
-    const mutationVerbs = ["Create", "Update", "Delete", "Remove", "Patch", "Post", "Set", "Add"];
-    let resource = method.name;
-    mutationVerbs.forEach((verb) => {
-      if (method.name.startsWith(verb))
-        resource = method.name.replace(verb, "");
-    });
-    rpcs.push({
-      functionName: camelName,
-      hookName: `use${method.name}`,
-      resource,
-      inputType: method.input.name,
-      outputType: method.output.name,
-      isQuery: method.methodKind === METHOD_KIND_UNARY && !mutationVerbs.some((v) => method.name.startsWith(v)),
-      isPaginated: isPaginatedDeep(method.input) && method.methodKind === METHOD_KIND_UNARY
-    });
+  const allMessages = new Set;
+  function track(msg) {
+    if (KNOWN_WKT.includes(msg.typeName)) {
+      wktImports.add(msg.name);
+      return;
+    }
+    if (allMessages.has(msg.name))
+      return;
+    allMessages.add(msg.name);
+    const importPath = `./gen/${msg.file.name.replace(".proto", "_pb")}`;
+    if (!importMap.has(importPath))
+      importMap.set(importPath, new Set);
+    importMap.get(importPath).add(msg.name);
+    msg.fields.forEach((f) => f.fieldKind === "message" && track(f.message));
   }
+  const rpcs = service.methods.map((m) => {
+    track(m.input);
+    track(m.output);
+    const isUnary = m.methodKind === METHOD_KIND_UNARY;
+    const verbs = [
+      "Create",
+      "Update",
+      "Delete",
+      "Remove",
+      "Patch",
+      "Post",
+      "Set",
+      "Add"
+    ];
+    const isMutation = verbs.some((v) => m.name.startsWith(v));
+    const reqPath = findPath(m.input, [
+      "page",
+      "offset",
+      "pagetoken",
+      "cursor",
+      "pagenumber"
+    ]);
+    const resPath = findPath(m.output, [
+      "nextpagetoken",
+      "nextpage",
+      "hasmore",
+      "nextcursor"
+    ]);
+    return {
+      functionName: m.name.charAt(0).toLowerCase() + m.name.slice(1),
+      hookName: `use${m.name}`,
+      resource: m.name.replace(/^(Get|ListAll|List|Create|Update|Delete|Remove|Patch|Post|Set|Add)/, ""),
+      inputType: m.input.name,
+      outputType: m.output.name,
+      isQuery: isUnary && !isMutation,
+      isPaginated: isUnary && !isMutation && !!reqPath && !!resPath,
+      reqPath: reqPath?.join("."),
+      resPath: resPath?.join(".")
+    };
+  });
   return {
     serviceName: service.name,
-    protoPbFile,
+    protoPbFile: service.file.name.replace(".proto", "_pb"),
     rpcs,
-    messageNames: Array.from(allSeenMessages).map((m) => m.split(".").pop()),
+    messageNames: Array.from(allMessages),
     wktImports: Array.from(wktImports),
-    localImports: Array.from(localImports),
-    externalImports: Array.from(externalImports.entries()).map(([path2, types2]) => ({
+    externalImports: Array.from(importMap.entries()).map(([path2, types2]) => ({
       path: path2,
       types: Array.from(types2)
     }))
@@ -336890,16 +336894,15 @@ function processService(service, protoPbFile) {
 }
 var plugin = createEcmaScriptPlugin({
   name: "protoc-gen-connect-vue",
-  version: "v1.0.3",
+  version: "v1.0.7",
   generateTs: (schema) => {
-    let firstService = schema.files.flatMap((f) => f.services)[0];
-    if (!firstService)
+    const service = schema.files.flatMap((f) => f.services)[0];
+    if (!service)
       return;
-    const protoFileStem = firstService.file.name.replace(".proto", "");
-    const viewData = processService(firstService, `${protoFileStem}_pb`);
-    schema.generateFile("client.ts").print(mustache_default.render(clientTemplate, viewData));
-    schema.generateFile("api.ts").print(mustache_default.render(apiTemplate, viewData, partials));
-    schema.generateFile("index.ts").print(mustache_default.render(indexTemplate, {}));
+    const data = processService(service);
+    schema.generateFile("client.ts").print(mustache_default.render(templates.client, data));
+    schema.generateFile("api.ts").print(mustache_default.render(templates.api, data, { rpc: templates.rpc }));
+    schema.generateFile("index.ts").print(mustache_default.render(templates.index, {}));
   }
 });
 runNodeJs(plugin);

package/package.json

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

package/templates/api.ts.mustache

@@ -1,28 +1,16 @@
 import { computed, unref } from "vue";
 import { 
-  useQuery, 
-  useMutation, 
-  useInfiniteQuery, 
-  useQueryClient, 
-  useIsFetching, 
-  useIsMutating 
+  useQuery, useMutation, useInfiniteQuery, useQueryClient, useIsFetching, useIsMutating 
 } from "@tanstack/vue-query";
 import { ConnectError } from "@connectrpc/connect";
-// FIXED: MessageInit is the correct type for 'create' payload
-import { create, type MessageInit } from "@bufbuild/protobuf";
+import { create } from "@bufbuild/protobuf";
 import { useGrpcClient } from "./client";
 
 {{#wktImports}}
-// FIXED: Path for v2 WKTs
 import { {{.}}Schema } from "@bufbuild/protobuf/wkt";
 import type { {{.}} } from "@bufbuild/protobuf/wkt";
 {{/wktImports}}
 
-{{#localImports}}
-import { {{.}}Schema } from "./gen/{{{protoPbFile}}}";
-import type { {{.}} } from "./gen/{{{protoPbFile}}}";
-{{/localImports}}
-
 {{#externalImports}}
 import { {{#types}}{{.}}Schema, {{/types}} } from "{{{path}}}";
 import type { {{#types}}{{.}}, {{/types}} } from "{{{path}}}";
@@ -31,18 +19,15 @@ import type { {{#types}}{{.}}, {{/types}} } from "{{{path}}}";
 export type APIResponse<T> = { error: string | null; data: T | null; };
 
 async function callConnect<ReqT, ResT, DataT>(
-  connectMethod: (req: ReqT) => Promise<ResT>,
-  request: ReqT,
-  dataExtractor: (res: ResT) => DataT
+  method: (req: ReqT) => Promise<ResT>,
+  req: ReqT,
+  extractor: (res: ResT) => DataT
 ): Promise<APIResponse<DataT>> {
   try {
-    const res = await connectMethod(request);
-    return { error: null, data: dataExtractor(res) };
+    const res = await method(req);
+    return { error: null, data: extractor(res) };
   } catch (err) {
-    return { 
-      error: err instanceof ConnectError ? err.message : "Unknown error", 
-      data: null 
-    };
+    return { error: err instanceof ConnectError ? err.message : "Unknown error", data: null };
   }
 }
 
@@ -52,34 +37,21 @@ export const queryKeys = {
   {{/rpcs}}
 };
 
-/**
- * Utility to create default/empty versions of Protobuf messages 
- */
 export const createEmpty = {
   {{#messageNames}}
-  {{.}}: (data?: MessageInit<{{.}}>) => create({{.}}Schema, data),
+  {{.}}: (data?: any) => create({{.}}Schema, data) as {{.}},
   {{/messageNames}}
 };
 
 export const useApi = () => {
   const { client } = useGrpcClient();
   const queryClient = useQueryClient();
+  const isGlobalLoading = computed(() => useIsFetching().value > 0 || useIsMutating().value > 0);
 
-  const isFetching = useIsFetching();
-  const isMutating = useIsMutating();
-  const isGlobalLoading = computed(() => isFetching.value > 0 || isMutating.value > 0);
-
-  {{#rpcs}}
-  {{> rpc}}
-  {{/rpcs}}
+  {{#rpcs}}{{> rpc}}{{/rpcs}}
 
   return {
-    {{#rpcs}}
-    {{functionName}},
-    {{hookName}},
-    {{/rpcs}}
-    isGlobalLoading,
-    queryKeys,
-    createEmpty
+    {{#rpcs}}{{functionName}}, {{hookName}}, {{/rpcs}}
+    isGlobalLoading, queryKeys, createEmpty
   };
 };

package/templates/rpc.ts.mustache

@@ -1,41 +1,41 @@
 /**
- * Standard Async: {{functionName}}
- * Used for manual actions. Invalidates the cache for this resource on success.
+ * Async Wrapper: {{functionName}}
  */
 const {{functionName}} = async (req: {{inputType}}): Promise<APIResponse<{{outputType}}>> => {
   const res = await callConnect(client.value.{{functionName}}.bind(client.value), req, (res) => res);
-  if (!res.error) {
-    queryClient.invalidateQueries({ queryKey: ["{{resource}}"] });
-  }
+  if (!res.error) queryClient.invalidateQueries({ queryKey: ["{{resource}}"] });
   return res;
 };
 
 /**
- * TanStack Hook: {{hookName}}
- * Provides reactive data binding with caching.
+ * Hook: {{hookName}}
  */
 const {{hookName}} = (
-  {{#isQuery}}
-  input: any, // Accepts Ref<{{inputType}}> or {{inputType}}
-  options: any = {}
-  {{/isQuery}}
-  {{^isQuery}}
-  options: any = {}
-  {{/isQuery}}
+  {{#isQuery}}input: any, options: any = {}{{/isQuery}}
+  {{^isQuery}}options: any = {}{{/isQuery}}
 ) => {
   {{#isPaginated}}
   return useInfiniteQuery({
     queryKey: queryKeys.{{functionName}}(input),
     queryFn: async ({ pageParam }) => {
-      const req = { ...unref(input), page: pageParam }; 
+      const req = JSON.parse(JSON.stringify(unref(input))); 
+      const path = "{{reqPath}}".split('.');
+      let curr = req;
+      for (let i = 0; i < path.length - 1; i++) {
+        curr[path[i]] = curr[path[i]] || {};
+        curr = curr[path[i]];
+      }
+      curr[path[path.length - 1]] = pageParam;
       return client.value.{{functionName}}(req);
     },
-    initialPageParam: 1,
-    getNextPageParam: (lastPage: any) => lastPage.nextPage ?? undefined,
+    initialPageParam: options.initialPageParam ?? 1,
+    getNextPageParam: (lastPage: any) => {
+      const path = "{{resPath}}".split('.');
+      return path.reduce((o, i) => o?.[i], lastPage) || undefined;
+    },
     ...options,
   });
   {{/isPaginated}}
-  
   {{^isPaginated}}
   {{#isQuery}}
   return useQuery({
@@ -44,13 +44,12 @@ const {{hookName}} = (
     ...options,
   });
   {{/isQuery}}
-  
   {{^isQuery}}
   return useMutation({
     mutationFn: (req: {{inputType}}) => client.value.{{functionName}}(req),
-    onSuccess: async (data, variables, context) => {
+    onSuccess: async (d, v, c) => {
       await queryClient.invalidateQueries({ queryKey: ["{{resource}}"] });
-      if (options.onSuccess) return options.onSuccess(data, variables, context);
+      if (options.onSuccess) return options.onSuccess(d, v, c);
     },
     ...options,
   });