feat: support grpc plugins with ts and bun

.github/workflows/cli-ci.yaml

@@ -34,6 +34,9 @@ jobs:
       - name: Generate code
         run: pnpm buf generate --template buf.ts.gen.yaml
 
+      - name: Generate router templates
+        run: pnpm --filter ./cli compile-templates
+
       - name: Check if git is not dirty after generating files
         run: git diff --no-ext-diff --exit-code
 

cli/courses/src/plugin.test.ts

@@ -0,0 +1,97 @@
+import { describe, test, expect } from "bun:test";
+import * as grpc from "@grpc/grpc-js";
+import type { Subprocess } from "bun";
+
+// Generated gRPC types
+import { CoursesServiceClient } from '../generated/service_grpc_pb.js';
+import { QueryHelloRequest, QueryHelloResponse } from "../generated/service_pb.js";
+
+function queryHello(client: CoursesServiceClient, name: string): Promise<QueryHelloResponse> {
+  return new Promise((resolve, reject) => {
+    const req = new QueryHelloRequest();
+    req.setName(name);
+    client.queryHello(req, (err, resp) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      if (!resp) {
+        reject(new Error("empty response"));
+        return;
+      }
+      resolve(resp);
+    });
+  });
+}
+
+describe("CoursesServiceService.queryHello", () => {
+  test("returns greeting with sequential world IDs", async () => {
+    const [subprocess, address] = await startPluginProcess();
+    const client = createClient(address);
+    try {
+      const cases = [
+        { name: "Alice", wantId: "world-1", wantName: "Hello from CoursesServiceService plugin! Alice" },
+        { name: "", wantId: "world-2", wantName: "Hello from CoursesServiceService plugin! " },
+        { name: "John & Jane", wantId: "world-3", wantName: "Hello from CoursesServiceService plugin! John & Jane" },
+      ];
+
+      for (const c of cases) {
+        const resp = await queryHello(client, c.name);
+        const world = resp.getHello();
+        expect(world).toBeTruthy();
+        expect(world!.getId()).toBe(c.wantId);
+        expect(world!.getName()).toBe(c.wantName);
+      }
+    } finally {
+      client.close();
+      subprocess.kill();
+    }
+  });
+
+  test("IDs increment across multiple requests in a fresh process", async () => {
+    const [subprocess, address] = await startPluginProcess();
+    const client = createClient(address);
+    try {
+      const first = await queryHello(client, "First");
+      expect(first.getHello()!.getId()).toBe("world-1");
+
+      const second = await queryHello(client, "Second");
+      expect(second.getHello()!.getId()).toBe("world-2");
+
+      const third = await queryHello(client, "Third");
+      expect(third.getHello()!.getId()).toBe("world-3");
+    } finally {
+      client.close();
+      subprocess.kill();
+    }
+  });
+});
+
+
+async function startPluginProcess(): Promise<[Subprocess, string]> {
+  const proc = Bun.spawn(["bun", "run", "src/plugin.ts"], {
+    stdout: "pipe",
+    stderr: "inherit",
+  });
+
+  // Read the first line from stdout and parse the address
+  if (!proc.stdout) {
+    throw new Error("plugin stdout not available");
+  }
+  const reader = proc.stdout.getReader();
+  const decoder = new TextDecoder();
+  const { value } = await reader.read();
+  reader.releaseLock();
+
+  const text = decoder.decode(value ?? new Uint8Array());
+  const firstLine = text.split("\n")[0]?.trim() ?? "";
+  const parts = firstLine.split("|");
+  const address = parts[3];
+
+  return [proc, address];
+}
+
+function createClient(address: string): CoursesServiceClient {
+  const target = `unix://$\\{address\\}`;
+  return new CoursesServiceClient(target, grpc.credentials.createInsecure());
+}

cli/package.json

@@ -19,6 +19,9 @@
     "url": "https://github.com/wundergraph/cosmo"
   },
   "scripts": {
+    "compile-templates": "tsx scripts/compile-templates.ts && prettier --write src/commands/router/commands/plugin/templates/*.ts",
+    "prebuild": "npm run compile-templates",
+    "prebuild:bun": "bun run compile-templates",
     "build": "rm -rf dist && tsc",
     "build:bun": "bun build --compile --production --outfile wgc src/index.ts",
     "wgc": "tsx --env-file .env src/index.ts",

cli/scripts/compile-templates.ts

@@ -0,0 +1,103 @@
+import { readFileSync, writeFileSync, readdirSync } from 'node:fs';
+import { join, basename } from 'node:path';
+
+interface TemplateMap {
+  [key: string]: string;
+}
+
+// Convert file names to camelCase property names
+function fileNameToPropertyName(fileName: string): string {
+  // Remove .template extension
+  let name = fileName.replace('.template', '');
+
+  // Handle special cases for dotfiles
+  if (name.startsWith('.')) {
+    name = name.slice(1); // Remove the dot
+  }
+
+  // Convert to camelCase
+  // Split by dots, dashes, underscores, and spaces
+  const parts = name.split(/[ ._-]/);
+
+  return parts
+    .map((part, index) => {
+      // Normalize all-caps words (like README -> Readme)
+      if (part === part.toUpperCase() && part.length > 1) {
+        part = part.charAt(0) + part.slice(1).toLowerCase();
+      }
+
+      if (index === 0) {
+        // First part: lowercase first char, preserve rest
+        return part.charAt(0).toLowerCase() + part.slice(1);
+      }
+      // Subsequent parts: uppercase first char, preserve rest
+      return part.charAt(0).toUpperCase() + part.slice(1);
+    })
+    .join('');
+}
+
+function compileTemplates(dir: string, outputFile: string, comment?: string) {
+  const files = readdirSync(dir).filter((f) => f.endsWith('.template'));
+
+  if (files.length === 0) {
+    console.log(`No templates found in ${dir}`);
+    return;
+  }
+
+  const templates: TemplateMap = {};
+
+  for (const file of files) {
+    const filePath = join(dir, file);
+    const content = readFileSync(filePath, 'utf8');
+
+    // Convert file name to property name
+    const key = fileNameToPropertyName(file);
+    templates[key] = content;
+  }
+
+  // Generate TypeScript file
+  const lines: string[] = [];
+
+  if (comment) {
+    lines.push(`// ${comment}`);
+  }
+  lines.push('// This file is auto-generated. Do not edit manually.');
+  lines.push('/* eslint-disable no-template-curly-in-string */');
+  lines.push('');
+
+  // Create const declarations
+  for (const [key, content] of Object.entries(templates)) {
+    lines.push(`const ${key} = ${JSON.stringify(content)};`);
+    lines.push('');
+  }
+
+  // Export default object
+  lines.push('export default {');
+  for (const key of Object.keys(templates)) {
+    lines.push(`  ${key},`);
+  }
+  lines.push('};');
+  lines.push('');
+
+  writeFileSync(outputFile, lines.join('\n'), 'utf8');
+  console.log(`Generated ${outputFile} with ${files.length} templates`);
+}
+
+// Compile all template subdirectories, generating <templates>/<folder>.ts in the templates root
+const templatesDir = 'src/commands/router/commands/plugin/templates';
+
+const entries = readdirSync(templatesDir, { withFileTypes: true });
+const subdirs = entries.filter((e: any) => e.isDirectory());
+
+if (subdirs.length === 0) {
+  console.log(`No template subdirectories found in ${templatesDir}`);
+} else {
+  for (const dirent of subdirs) {
+    const dirName = dirent.name;
+    const dirPath = join(templatesDir, dirName);
+    const outFile = join(templatesDir, `${dirName}.ts`);
+    const comment = `Templates for ${dirName} (templating is done by pupa)`;
+    compileTemplates(dirPath, outFile, comment);
+  }
+  console.log('All templates compiled successfully');
+}

cli/src/commands/router/commands/plugin/commands/build.ts

@@ -6,12 +6,15 @@ import Spinner from 'ora';
 import { BaseCommandOptions } from '../../../../../core/types/types.js';
 import { renderResultTree } from '../helper.js';
 import {
-  buildBinaries,
+  buildGoBinaries,
   checkAndInstallTools,
   generateGRPCCode,
   generateProtoAndMapping,
-  HOST_PLATFORM,
+  getLanguage,
   installGoDependencies,
+  installTsDependencies,
+  typeCheckTs,
+  buildTsBinaries,
   normalizePlatforms,
 } from '../toolchain.js';
 
@@ -21,9 +24,11 @@ export default (opts: BaseCommandOptions) => {
   command.argument('[directory]', 'Directory of the plugin', '.');
   command.option('--generate-only', 'Generate only the proto and mapping files, do not compile the plugin');
   command.option('--debug', 'Build the binary with debug information', false);
-  command.option('--platform [platforms...]', 'Platform-architecture combinations (e.g., darwin-arm64 linux-amd64)', [
-    HOST_PLATFORM,
-  ]);
+  command.option(
+    '--platform [platforms...]',
+    'Platform-architecture combinations (e.g., darwin-arm64 linux-amd64)',
+    [],
+  );
   command.option('--all-platforms', 'Build for all supported platforms', false);
   command.option('--skip-tools-installation', 'Skip tool installation', false);
   command.option(
@@ -46,29 +51,45 @@ export default (opts: BaseCommandOptions) => {
     let platforms: string[] = [];
 
     try {
+      const language = getLanguage(pluginDir);
+
       // Check and install tools if needed
       if (!options.skipToolsInstallation) {
         await checkAndInstallTools(options.forceToolsInstallation);
       }
 
-      // Normalize platform list
-      platforms = normalizePlatforms(options.platform, options.allPlatforms);
-
       // Start the main build process
       spinner.start('Building plugin...');
 
+      switch (language) {
+        case 'ts': {
+          await installTsDependencies(pluginDir, spinner);
+          break;
+        }
+      }
+
+      // Normalize platform list
+      platforms = normalizePlatforms(options.platform, options.allPlatforms, language);
+
       // Generate proto and mapping files
       await generateProtoAndMapping(pluginDir, goModulePath, spinner);
 
       // Generate gRPC code
-      await generateGRPCCode(pluginDir, spinner);
+      await generateGRPCCode(pluginDir, spinner, language);
 
       if (!options.generateOnly) {
-        // Install Go dependencies
-        await installGoDependencies(pluginDir, spinner);
-
-        // Build binaries for all platforms
-        await buildBinaries(pluginDir, platforms, options.debug, spinner);
+        switch (language) {
+          case 'go': {
+            await installGoDependencies(pluginDir, spinner);
+            await buildGoBinaries(pluginDir, platforms, options.debug, spinner);
+            break;
+          }
+          case 'ts': {
+            await typeCheckTs(pluginDir, spinner);
+            await buildTsBinaries(pluginDir, platforms, options.debug, spinner);
+            break;
+          }
+        }
       }
 
       // Calculate and format elapsed time

cli/src/commands/router/commands/plugin/commands/generate.ts

@@ -9,7 +9,9 @@ import {
   checkAndInstallTools,
   generateGRPCCode,
   generateProtoAndMapping,
+  getLanguage,
   installGoDependencies,
+  installTsDependencies,
 } from '../toolchain.js';
 
 export default (opts: BaseCommandOptions) => {
@@ -36,22 +38,35 @@ export default (opts: BaseCommandOptions) => {
     const goModulePath = options.goModulePath;
 
     try {
+      const language = getLanguage(pluginDir);
+
       // Check and install tools if needed
       if (!options.skipToolsInstallation) {
         await checkAndInstallTools(options.forceToolsInstallation);
       }
 
+      switch (language) {
+        case 'ts': {
+          await installTsDependencies(pluginDir, spinner);
+          break;
+        }
+      }
+
       // Start the generation process
       spinner.start('Generating plugin code...');
 
       // Generate proto and mapping files
       await generateProtoAndMapping(pluginDir, goModulePath, spinner);
 
       // Generate gRPC code
-      await generateGRPCCode(pluginDir, spinner);
+      await generateGRPCCode(pluginDir, spinner, language);
 
-      // Install Go dependencies
-      await installGoDependencies(pluginDir, spinner);
+      switch (language) {
+        case 'go': {
+          await installGoDependencies(pluginDir, spinner);
+          break;
+        }
+      }
 
       // Calculate and format elapsed time
       const endTime = performance.now();