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

package/dist/generator.js

@@ -336793,69 +336793,58 @@ 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" && isPaginatedDeep(field.message, visited))
-      return true;
+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 false;
-}
-function resolveImportPath(message) {
-  return `./gen/${message.file.name.replace(".proto", "_pb")}`;
+  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) {
-  const rpcs = [];
-  const wktImports = new Set;
   const importMap = new Map;
-  const allMessages = new Map;
-  function trackMessage(msg) {
-    if (allMessages.has(msg.name))
-      return;
-    const fullTypeName = msg.typeName;
-    if (KNOWN_TYPES[fullTypeName]) {
-      wktImports.add(KNOWN_TYPES[fullTypeName]);
-      allMessages.set(KNOWN_TYPES[fullTypeName], "@bufbuild/protobuf/wkt");
+  const wktImports = new Set;
+  const allMessages = new Set;
+  function track(msg) {
+    if (KNOWN_WKT.includes(msg.typeName)) {
+      wktImports.add(msg.name);
       return;
     }
-    const targetPath = resolveImportPath(msg);
-    if (!importMap.has(targetPath))
-      importMap.set(targetPath, new Set);
-    importMap.get(targetPath).add(msg.name);
-    allMessages.set(msg.name, targetPath);
-    for (const field of msg.fields) {
-      if (field.fieldKind === "message")
-        trackMessage(field.message);
-    }
+    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));
   }
-  for (const method of service.methods) {
-    trackMessage(method.input);
-    trackMessage(method.output);
-    const mutationVerbs = [
+  const rpcs = service.methods.map((m) => {
+    track(m.input);
+    track(m.output);
+    const isUnary = m.methodKind === METHOD_KIND_UNARY;
+    const verbs = [
       "Create",
       "Update",
       "Delete",
@@ -336865,27 +336854,37 @@ function processService(service) {
       "Set",
       "Add"
     ];
-    const camelName = method.name.charAt(0).toLowerCase() + method.name.slice(1);
-    let resource = method.name;
-    mutationVerbs.forEach((v) => {
-      if (method.name.startsWith(v))
-        resource = method.name.replace(v, "");
-    });
-    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 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: service.file.name.replace(".proto", "_pb"),
     rpcs,
-    messageNames: Array.from(allMessages.keys()),
+    messageNames: Array.from(allMessages),
     wktImports: Array.from(wktImports),
     externalImports: Array.from(importMap.entries()).map(([path2, types2]) => ({
       path: path2,
@@ -336895,15 +336894,15 @@ function processService(service) {
 }
 var plugin = createEcmaScriptPlugin({
   name: "protoc-gen-connect-vue",
-  version: "v1.0.4",
+  version: "v1.0.7",
   generateTs: (schema) => {
-    const firstService = schema.files.flatMap((f) => f.services)[0];
-    if (!firstService)
+    const service = schema.files.flatMap((f) => f.services)[0];
+    if (!service)
       return;
-    const viewData = processService(firstService);
-    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.9",
+  "version": "1.0.10",
   "description": "Smart TanStack Query & ConnectRPC SDK generator for Vue.js",
   "type": "module",
   "license": "MIT",

package/templates/api.ts.mustache

@@ -1,14 +1,9 @@
 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";
-import { create, type MessageInit } from "@bufbuild/protobuf";
+import { create } from "@bufbuild/protobuf";
 import { useGrpcClient } from "./client";
 
 {{#wktImports}}
@@ -24,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 };
   }
 }
 
@@ -47,29 +39,19 @@ export const queryKeys = {
 
 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,
   });