stacked-server-typescript-types 1.1.3

package/eslint.config.mjs

@@ -0,0 +1,15 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+  { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], plugins: { js }, extends: ["js/recommended"], languageOptions: { globals: globals.browser } },
+  tseslint.configs.recommended,
+  {
+    files: ["**/*.{ts,mts,cts}"],
+    rules: {
+      "@typescript-eslint/no-unused-vars": "off",
+    },
+  },
+]);

package/generate-index.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+/**
+ * Generate index.ts that exports everything from endpoint files
+ * with conflict resolution for duplicate names
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const outputDir = process.argv[2];
+
+if (!outputDir) {
+    console.error('Usage: generate-index.js <output-dir>');
+    process.exit(1);
+}
+
+if (!fs.existsSync(outputDir)) {
+    console.error(`Output directory not found: ${outputDir}`);
+    process.exit(1);
+}
+
+// Find all endpoint files
+const endpointFiles = fs.readdirSync(outputDir)
+    .filter(f => f.endsWith('-endpoints.ts'))
+    .sort();
+
+if (endpointFiles.length === 0) {
+    console.log('No endpoint files found');
+    process.exit(0);
+}
+
+// Parse each file to extract exported names
+const fileExports = {};
+const allExports = {};
+
+for (const file of endpointFiles) {
+    const filePath = path.join(outputDir, file);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const baseName = file.replace('-endpoints.ts', '');
+    
+    // Convert to PascalCase for prefix (e.g., "post" -> "Post", "creator" -> "Creator")
+    const prefix = baseName.charAt(0).toUpperCase() + baseName.slice(1);
+    
+    fileExports[file] = {
+        baseName,
+        prefix,
+        exports: []
+    };
+    
+    // Match "export const ServiceName = {" for service objects
+    const constMatch = content.match(/export const (\w+)\s*=/g);
+    if (constMatch) {
+        for (const match of constMatch) {
+            const name = match.match(/export const (\w+)/)[1];
+            fileExports[file].exports.push({ name, type: 'const' });
+            
+            if (!allExports[name]) {
+                allExports[name] = [];
+            }
+            allExports[name].push({ file, prefix, type: 'const' });
+        }
+    }
+    
+    // Match "export type { Type1, Type2, ... } from" for re-exported types
+    const typeExportMatch = content.match(/export type \{([^}]+)\} from/g);
+    if (typeExportMatch) {
+        for (const match of typeExportMatch) {
+            const typesStr = match.match(/export type \{([^}]+)\}/)[1];
+            const types = typesStr.split(',').map(t => t.trim()).filter(t => t);
+            
+            for (const typeName of types) {
+                fileExports[file].exports.push({ name: typeName, type: 'type' });
+                
+                if (!allExports[typeName]) {
+                    allExports[typeName] = [];
+                }
+                allExports[typeName].push({ file, prefix, type: 'type' });
+            }
+        }
+    }
+}
+
+// Find conflicts (names exported from multiple files)
+const conflicts = {};
+for (const [name, sources] of Object.entries(allExports)) {
+    if (sources.length > 1) {
+        conflicts[name] = sources;
+    }
+}
+
+// Generate index.ts content
+let indexContent = `// Auto-generated index file
+// This file exports all service endpoints and types
+// Conflicting names are prefixed with the service name
+
+`;
+
+// Group exports by file
+for (const file of endpointFiles) {
+    const { prefix, exports } = fileExports[file];
+    const fileBaseName = file.replace('.ts', '');
+
+    // Separate conflicting and non-conflicting exports
+    const nonConflictingConsts = [];
+    const conflictingConsts = [];
+    const nonConflictingTypes = [];
+    const conflictingTypes = [];
+
+    for (const exp of exports) {
+        if (conflicts[exp.name]) {
+            if (exp.type === 'const') {
+                conflictingConsts.push(exp.name);
+            } else {
+                conflictingTypes.push(exp.name);
+            }
+        } else {
+            if (exp.type === 'const') {
+                nonConflictingConsts.push(exp.name);
+            } else {
+                nonConflictingTypes.push(exp.name);
+            }
+        }
+    }
+
+    // Add comment for this service
+    indexContent += `// ${prefix} Service\n`;
+
+    // Export non-conflicting consts directly
+    if (nonConflictingConsts.length > 0) {
+        indexContent += `export { ${nonConflictingConsts.join(', ')} } from './${fileBaseName}';\n`;
+    }
+
+    // Export non-conflicting types directly
+    if (nonConflictingTypes.length > 0) {
+        indexContent += `export type { ${nonConflictingTypes.join(', ')} } from './${fileBaseName}';\n`;
+    }
+
+    // Export conflicting consts with prefix
+    for (const name of conflictingConsts) {
+        // e.g. HealthCheck collisions -> PostServiceHealthCheck etc.
+        const prefixedName = `${prefix}${name}`;
+        indexContent += `export { ${name} as ${prefixedName} } from './${fileBaseName}';\n`;
+    }
+
+    // Export conflicting types with prefix
+    for (const name of conflictingTypes) {
+        const prefixedName = `${prefix}${name}`;
+        indexContent += `export type { ${name} as ${prefixedName} } from './${fileBaseName}';\n`;
+    }
+
+    indexContent += '\n';
+}
+
+// Write the index file
+const indexPath = path.join(outputDir, 'index.ts');
+fs.writeFileSync(indexPath, indexContent);
+console.log(`Generated index.ts with ${endpointFiles.length} service files`);
+console.log(`Found ${Object.keys(conflicts).length} naming conflicts that were prefixed`);

package/generate-typescript-types.sh

@@ -0,0 +1,508 @@
+#!/bin/sh
+
+# Exit immediately on error and undefined variables.
+set -eu
+
+# Enable pipefail when supported.
+(set -o pipefail) 2>/dev/null && set -o pipefail || true
+
+# Configuration
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+SERVER_DIR=$(dirname "$SCRIPT_DIR")
+OUTPUT_DIR="$SERVER_DIR/generated-types"
+TEMP_DIR="$SCRIPT_DIR/.types-temp"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+print_info() {
+    printf "%b[INFO]%b %s\n" "$GREEN" "$NC" "$1"
+}
+
+print_warn() {
+    printf "%b[WARN]%b %s\n" "$YELLOW" "$NC" "$1"
+}
+
+print_error() {
+    printf "%b[ERROR]%b %s\n" "$RED" "$NC" "$1"
+}
+
+# Cleanup function
+cleanup() {
+    if [ -d "$TEMP_DIR" ]; then
+        print_info "Cleaning up temporary files..."
+        rm -rf "$TEMP_DIR"
+    fi
+}
+
+# Set trap to cleanup on exit
+trap cleanup EXIT
+
+# Check for required tools
+check_dependencies() {
+    print_info "Checking dependencies..."
+    
+    # Check for protoc
+    if ! command -v protoc >/dev/null 2>&1; then
+        print_error "protoc is not installed. Please install it first."
+        exit 1
+    fi
+    
+    # Check for protoc-gen-openapiv2
+    openapi_plugin=""
+    if command -v protoc-gen-openapiv2 >/dev/null 2>&1; then
+        openapi_plugin="protoc-gen-openapiv2"
+    elif [ -f "$HOME/go/bin/protoc-gen-openapiv2" ]; then
+        openapi_plugin="$HOME/go/bin/protoc-gen-openapiv2"
+    elif [ -n "${GOPATH:-}" ] && [ -f "$GOPATH/bin/protoc-gen-openapiv2" ]; then
+        openapi_plugin="$GOPATH/bin/protoc-gen-openapiv2"
+    else
+        print_warn "protoc-gen-openapiv2 not found. Attempting to install..."
+        # Try to install, but don't fail if it doesn't work
+        if command -v go >/dev/null 2>&1; then
+            go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@latest 2>&1 | grep -v "GOROOT" || true
+            if [ -f "$HOME/go/bin/protoc-gen-openapiv2" ]; then
+                openapi_plugin="$HOME/go/bin/protoc-gen-openapiv2"
+            elif [ -n "${GOPATH:-}" ] && [ -f "$GOPATH/bin/protoc-gen-openapiv2" ]; then
+                openapi_plugin="$GOPATH/bin/protoc-gen-openapiv2"
+            fi
+        fi
+    fi
+    
+    if [ -z "$openapi_plugin" ]; then
+        print_warn "protoc-gen-openapiv2 not found. OpenAPI generation will be skipped."
+        print_warn "Please install it manually: go install github.com/grpc-ecosystem/grpc-gateway/v2/protoc-gen-openapiv2@latest"
+        export OPENAPI_PLUGIN_PATH=""
+    else
+        export OPENAPI_PLUGIN_PATH="$openapi_plugin"
+        print_info "Found protoc-gen-openapiv2 at: $openapi_plugin"
+    fi
+    
+    # Check for Node.js and npm
+    if ! command -v node >/dev/null 2>&1; then
+        print_error "Node.js is not installed. Please install it first."
+        exit 1
+    fi
+    
+    if ! command -v npm >/dev/null 2>&1; then
+        print_error "npm is not installed. Please install it first."
+        exit 1
+    fi
+    
+    # Install npm dependencies if node_modules doesn't exist in server directory
+    if [ ! -d "$SCRIPT_DIR/node_modules" ]; then
+        print_info "Installing npm dependencies..."
+        (cd "$SCRIPT_DIR" && npm install)
+    fi
+    
+    print_info "All dependencies are available"
+}
+
+# Find proto files (excluding google protos)
+find_proto_files() {
+    find "$SERVER_DIR/services" -name '*.proto' | grep -v '/google/' | sort
+}
+
+# Generate TypeScript message types using ts-proto
+generate_ts_proto_types() {
+    print_info "Generating TypeScript message types using ts-proto..."
+
+    proto_files=$(find_proto_files)
+    ts_proto_dir="$TEMP_DIR/ts-proto"
+    mkdir -p "$ts_proto_dir"
+
+    # Find ts-proto plugin once
+    plugin_bin=""
+    if [ -f "$SCRIPT_DIR/node_modules/.bin/protoc-gen-ts_proto" ]; then
+        plugin_bin="$SCRIPT_DIR/node_modules/.bin/protoc-gen-ts_proto"
+    elif command -v protoc-gen-ts_proto >/dev/null 2>&1; then
+        plugin_bin="$(command -v protoc-gen-ts_proto)"
+    else
+        print_warn "ts-proto plugin not found, trying to install..."
+        (cd "$SCRIPT_DIR" && npm install --save-dev ts-proto 2>&1 | grep -v "npm WARN" || true)
+        if [ -f "$SCRIPT_DIR/node_modules/.bin/protoc-gen-ts_proto" ]; then
+            plugin_bin="$SCRIPT_DIR/node_modules/.bin/protoc-gen-ts_proto"
+        else
+            print_error "Failed to find ts-proto plugin"
+            return 1
+        fi
+    fi
+
+    print_info "Using ts-proto plugin: $plugin_bin"
+
+    # Find Google's well-known protos include path
+    google_proto_path=""
+    if [ -d "/usr/local/include/google/protobuf" ]; then
+        google_proto_path="/usr/local/include"
+    elif [ -d "/opt/homebrew/include/google/protobuf" ]; then
+        google_proto_path="/opt/homebrew/include"
+    elif [ -d "$HOME/.local/include/google/protobuf" ]; then
+        google_proto_path="$HOME/.local/include"
+    fi
+
+    google_include=""
+    if [ -n "$google_proto_path" ]; then
+        google_include="-I$google_proto_path"
+    fi
+
+    # Also emit TS for well-known Google protos referenced by our service protos (e.g., wrappers.proto)
+    # so downstream imports like BoolValue resolve from generated-types/messages/google/protobuf.
+    if [ -n "$google_proto_path" ]; then
+        print_info "Generating TS for google/protobuf well-known types (wrappers, timestamp, empty, struct)..."
+
+        wk_protos="wrappers.proto timestamp.proto empty.proto struct.proto"
+        for wk in $wk_protos; do
+            wk_file="$google_proto_path/google/protobuf/$wk"
+            if [ -f "$wk_file" ]; then
+                print_info "  - $wk"
+                protoc \
+                    $google_include \
+                    --plugin=protoc-gen-ts_proto="$plugin_bin" \
+                    --ts_proto_opt=esModuleInterop=true,forceLong=string,useOptionals=messages \
+                    --ts_proto_out="$ts_proto_dir" \
+                    "$wk_file" \
+                    2>&1 | grep -v "google/protobuf" | grep -v "^$" || true
+            else
+                print_warn "Well-known proto not found: $wk_file"
+            fi
+        done
+    else
+        print_warn "Google well-known protos include path not found; will not generate wrappers/timestamp/empty/struct TS types"
+        print_warn "Install protobuf includes (e.g., via Homebrew) so google/protobuf/wrappers.proto can be generated"
+    fi
+
+    for proto_file in $proto_files; do
+        dir=$(dirname "$proto_file")
+        base=$(basename "$proto_file" .proto)
+
+        print_info "Processing $proto_file..."
+
+        # Find google/api protos (for annotations.proto)
+        google_api_path=""
+        if [ -d "$SERVER_DIR/services/google" ]; then
+            google_api_path="-I$SERVER_DIR/services"
+        elif [ -d "$dir/google" ]; then
+            google_api_path="-I$dir"
+        elif [ -d "$dir/../google" ]; then
+            google_api_path="-I$dir/.."
+        elif [ -d "$dir/../../google" ]; then
+            google_api_path="-I$dir/../.."
+        fi
+
+        protoc_exit_code=0
+        protoc_output=$(protoc \
+            -I"$SERVER_DIR/services" \
+            $google_api_path \
+            $google_include \
+            --plugin=protoc-gen-ts_proto="$plugin_bin" \
+            --ts_proto_opt=esModuleInterop=true,forceLong=string,useOptionals=messages \
+            --ts_proto_out="$ts_proto_dir" \
+            "$proto_file" \
+            2>&1) || protoc_exit_code=$?
+
+        filtered_output=$(echo "$protoc_output" | grep -v "google/protobuf" | grep -v "^$" || true)
+        if [ -n "$filtered_output" ]; then
+            echo "$filtered_output"
+        fi
+
+        if [ $protoc_exit_code -ne 0 ]; then
+            exit 1
+        fi
+    done
+
+    print_info "TypeScript message types generated"
+}
+
+# Generate OpenAPI specs using protoc-gen-openapiv2
+generate_openapi_specs() {
+    print_info "Generating OpenAPI specs using protoc-gen-openapiv2..."
+
+    proto_files=$(find_proto_files)
+    openapi_dir="$TEMP_DIR/openapi"
+    mkdir -p "$openapi_dir"
+
+    # Detect whether protoc-gen-openapiv2 supports include_source_info
+    include_source_info_opt=""
+    if [ -n "${OPENAPI_PLUGIN_PATH:-}" ]; then
+        # Help output differs by version; use a conservative grep.
+        if "$OPENAPI_PLUGIN_PATH" --help 2>&1 | grep -q "include_source_info"; then
+            include_source_info_opt="--openapiv2_opt=include_source_info=true"
+            print_info "protoc-gen-openapiv2 supports include_source_info=true"
+        else
+            print_warn "protoc-gen-openapiv2 does not support include_source_info; skipping that option"
+        fi
+    fi
+
+    for proto_file in $proto_files; do
+        dir=$(dirname "$proto_file")
+        base=$(basename "$proto_file" .proto)
+        service_dir=$(echo "$dir" | sed "s|$SERVER_DIR/services/||" | sed 's|/protos||')
+
+        print_info "Generating OpenAPI spec for $proto_file..."
+
+        (
+            cd "$dir"
+
+            # Generate OpenAPI spec
+            if [ -z "$OPENAPI_PLUGIN_PATH" ]; then
+                print_warn "Skipping OpenAPI generation for $proto_file (plugin not available)"
+                continue
+            fi
+
+            plugin_arg=""
+            if [ -n "$OPENAPI_PLUGIN_PATH" ] && [ "$OPENAPI_PLUGIN_PATH" != "protoc-gen-openapiv2" ]; then
+                plugin_arg="--plugin=protoc-gen-openapiv2=$OPENAPI_PLUGIN_PATH"
+            fi
+
+            protoc -I. -I../../../../ -I./ \
+                $plugin_arg \
+                --openapiv2_out="$openapi_dir" \
+                --openapiv2_opt=logtostderr=true \
+                --openapiv2_opt=allow_merge=true \
+                --openapiv2_opt=merge_file_name="$base" \
+                --openapiv2_opt=openapi_naming_strategy=simple \
+                ${include_source_info_opt:-} \
+                "$base.proto" 2>&1 | grep -v "google/protobuf" || true
+        )
+    done
+
+    print_info "OpenAPI specs generated"
+}
+
+# Process OpenAPI specs (we'll use the JSON directly, not convert to TS first)
+process_openapi_specs() {
+    print_info "Processing OpenAPI specs..."
+    
+    openapi_dir="$TEMP_DIR/openapi"
+    
+    # Find all OpenAPI spec files
+    openapi_files=$(find "$openapi_dir" -name "*.swagger.json" -o -name "*.json" | grep -v "google")
+    
+    if [ -z "$openapi_files" ]; then
+        print_warn "No OpenAPI spec files found"
+        return
+    fi
+    
+    print_info "Found OpenAPI spec files, will process them in combine_outputs"
+}
+
+# Generate *-endpoints.ts files from all OpenAPI specs using the Node processor.
+generate_endpoints_from_openapi() {
+    print_info "Generating *-endpoints.ts files from OpenAPI specs..."
+
+    openapi_dir="$TEMP_DIR/openapi"
+    if [ ! -d "$openapi_dir" ]; then
+        print_warn "OpenAPI directory not found: $openapi_dir"
+        return
+    fi
+
+    openapi_files=$(find "$openapi_dir" -name "*.swagger.json" -o -name "*.json" | grep -v "google" || true)
+    if [ -z "${openapi_files:-}" ]; then
+        print_warn "No OpenAPI spec files found for endpoint generation"
+        return
+    fi
+
+    processor="$SCRIPT_DIR/process-openapi-types.js"
+    if [ ! -f "$processor" ]; then
+        print_error "OpenAPI processor not found: $processor"
+        exit 1
+    fi
+
+    for spec in $openapi_files; do
+        base=$(basename "$spec")
+        service=$(echo "$base" | sed 's/\.swagger\.json$//' | sed 's/\.json$//')
+
+        # outputFile is used only to determine the output directory and some message type inference.
+        # We keep it inside OUTPUT_DIR.
+        out_stub="$OUTPUT_DIR/${service}-types.ts"
+
+        print_info "Generating endpoints for $service from $base"
+        node "$processor" "$spec" "$out_stub" "$service" "$OUTPUT_DIR/messages" "$SERVER_DIR" || true
+    done
+}
+
+# Convert interfaces to types in generated files
+convert_interfaces_to_types() {
+    target_dir="$1"
+    print_info "Converting interfaces to types..."
+
+    # The previous sed-based approach corrupted the ts-proto output by removing the interface body.
+    # This transform preserves the entire interface block and just changes `export interface X` -> `export type X =`.
+    find "$target_dir" -name "*.ts" -type f ! -name "index.ts" | while read -r file; do
+        perl -0777 -i -pe 's/^export\s+interface\s+([A-Za-z_][A-ZaZ0-9_]*)\s*\{/export type $1 = { /mg' "$file"
+    done
+}
+
+# Flatten ts-proto output so service protos land directly in generated-types/messages (e.g. messages/user.ts)
+# and rewrite internal imports to valid relative paths in the flattened structure.
+flatten_messages() {
+    ts_proto_dir="$1"
+    out_messages_dir="$2"
+
+    print_info "Flattening generated message files into $out_messages_dir ..."
+
+    rm -rf "$out_messages_dir"
+    mkdir -p "$out_messages_dir"
+
+    # 1) Copy google well-known types (preserve nested path google/protobuf)
+    if [ -d "$ts_proto_dir/google" ]; then
+        mkdir -p "$out_messages_dir/google"
+        cp -R "$ts_proto_dir/google" "$out_messages_dir/" 2>/dev/null || true
+    fi
+
+    # 2) Copy non-google generated proto outputs (flatten)
+    # We take the last path segment as the module name (e.g. config-service/protos/config.ts -> config.ts)
+    find "$ts_proto_dir" -type f -name "*.ts" | while read -r f; do
+        rel="${f#$ts_proto_dir/}"
+
+        case "$rel" in
+            google/*) continue ;; # already handled
+        esac
+
+        base=$(basename "$f")
+
+        # Avoid overwriting if there are name collisions; warn and skip.
+        if [ -f "$out_messages_dir/$base" ]; then
+            print_warn "Flatten skip (name collision): $rel -> $base"
+            continue
+        fi
+
+        cp "$f" "$out_messages_dir/$base"
+    done
+
+    # 3) Rewrite imports in flattened files so they resolve in the new layout.
+    # ts-proto emits imports like: import { Empty } from "../../google/protobuf/empty";
+    # After flattening, the correct path is: import { Empty } from "./google/protobuf/empty";
+    find "$out_messages_dir" -type f -name "*.ts" | while read -r file; do
+        # Only rewrite in top-level flattened files; google/protobuf files keep theirs.
+        case "$file" in
+            *"/google/protobuf/"*) continue ;;
+        esac
+
+        perl -i -pe 's/from "\.\.\/\.\.\/google\/protobuf\//from "\.\/google\/protobuf\//g' "$file"
+        perl -i -pe 's/from "\.\.\/\.\.\/\.\.\/google\/protobuf\//from "\.\/google\/protobuf\//g' "$file"
+        perl -i -pe 's/from "\.\.\/google\/protobuf\//from "\.\/google\/protobuf\//g' "$file"
+    done
+}
+
+# Re-export google/protobuf imports from each top-level message file.
+# We ensure the symbols are BOTH imported (so local references compile) and re-exported
+# (so downstream can import them from the message module).
+reexport_google_imports() {
+    out_messages_dir="$1"
+
+    print_info "Ensuring ./google/protobuf symbols are imported + re-exported from flattened message files..."
+
+    find "$out_messages_dir" -maxdepth 1 -type f -name "*.ts" ! -name "index.ts" | while read -r file; do
+        # Skip the google-protobuf generated files themselves
+        case "$file" in
+            *"/google/"*) continue ;;
+        esac
+
+        # 1) If we previously converted imports to re-exports, restore them to import+export.
+        #    export { X } from "./google/protobuf/wrappers";
+        # -> import { X } from "./google/protobuf/wrappers";
+        #    export { X };
+        perl -0777 -i -pe 's/^export\s+\{\s*([^}]+?)\s*\}\s+from\s+"(\.\/google\/protobuf\/[^\"]+)"\s*;\s*$/import { $1 } from "$2";\nexport { $1 };\n/mg' "$file"
+
+        # 2) Same for type-only.
+        #    export type { X } from "./google/protobuf/wrappers";
+        # -> import type { X } from "./google/protobuf/wrappers";
+        #    export type { X };
+        perl -0777 -i -pe 's/^export\s+type\s+\{\s*([^}]+?)\s*\}\s+from\s+"(\.\/google\/protobuf\/[^\"]+)"\s*;\s*$/import type { $1 } from "$2";\nexport type { $1 };\n/mg' "$file"
+
+        # 3) If file still has plain imports, add a matching export line.
+        #    import { X } from "./google/protobuf/wrappers";
+        # -> import { X } from "./google/protobuf/wrappers";
+        #    export { X };
+        perl -0777 -i -pe 's/^import\s+\{\s*([^}]+?)\s*\}\s+from\s+"(\.\/google\/protobuf\/[^\"]+)"\s*;\s*$/import { $1 } from "$2";\nexport { $1 };\n/mg' "$file"
+
+        perl -0777 -i -pe 's/^import\s+type\s+\{\s*([^}]+?)\s*\}\s+from\s+"(\.\/google\/protobuf\/[^\"]+)"\s*;\s*$/import type { $1 } from "$2";\nexport type { $1 };\n/mg' "$file"
+    done
+}
+
+# Generate a top-level index.ts that exports per-service endpoints consts and namespaced message types
+generate_generated_types_index() {
+    out_dir="$1"
+    messages_dir="$out_dir/messages"
+
+    print_info "Generating $out_dir/index.ts ..."
+
+    endpoints_files=$(find "$out_dir" -maxdepth 1 -type f -name "*-endpoints.ts" | sort || true)
+
+    # Helper: kebab-case -> PascalCase (e.g. data-analysis -> DataAnalysis)
+    to_pascal() {
+        perl -pe '$_=join("", map { ucfirst($_) } split(/-/, $_)); chomp' <<< "$1"
+    }
+
+    {
+        echo "// Auto-generated barrel file for generated-types"
+        echo ""
+        echo "export * from './envWrapper';"
+        echo ""
+
+        for f in $endpoints_files; do
+            base=$(basename "$f" "-endpoints.ts")
+            svc=$(to_pascal "$base")
+            service_const="${svc}Service"
+
+            # Re-export the service const only (keeps endpoint surface simple)
+            echo "export { ${service_const} } from './${base}-endpoints';"
+
+            # Export message types under a namespace to avoid collisions
+            msg_guess_a="$messages_dir/${base}.ts"
+            msg_guess_b="$messages_dir/$(echo "$base" | tr '-' '_').ts"
+
+            if [ -f "$msg_guess_a" ]; then
+                echo "export * as ${svc}Types from './messages/${base}';"
+            elif [ -f "$msg_guess_b" ]; then
+                msg_mod=$(basename "$msg_guess_b" .ts)
+                echo "export * as ${svc}Types from './messages/${msg_mod}';"
+            else
+                print_warn "No message module found for ${base}: expected $msg_guess_a or $msg_guess_b" >&2
+            fi
+
+            echo ""
+        done
+    } > "$out_dir/index.ts"
+}
+
+# ---- Main ----
+main() {
+    check_dependencies
+
+    # Fresh temp
+    rm -rf "$TEMP_DIR"
+    mkdir -p "$TEMP_DIR"
+
+    # Generate message types and OpenAPI specs
+    generate_ts_proto_types
+    generate_openapi_specs
+    process_openapi_specs
+
+    # Write/flatten messages
+    flatten_messages "$TEMP_DIR/ts-proto" "$OUTPUT_DIR/messages"
+
+    # Ensure google wrapper imports are re-exported from top-level message files
+    reexport_google_imports "$OUTPUT_DIR/messages"
+
+    # Convert interfaces to types (optional)
+    convert_interfaces_to_types "$OUTPUT_DIR/messages"
+
+    # Generate endpoints from OpenAPI specs
+    generate_endpoints_from_openapi
+
+    # Generate top-level barrel exports
+    generate_generated_types_index "$OUTPUT_DIR"
+
+    # Copy package files
+    cp "$SCRIPT_DIR/typegen-package.json" "$OUTPUT_DIR/package.json"
+    cp "$SCRIPT_DIR/eslint.config.mjs" "$OUTPUT_DIR/eslint.config.mjs"
+
+    print_info "Done"
+}
+
+main "$@"

package/mock_proto_types/empty.ts

@@ -0,0 +1,12 @@
+// Code generated-ish fallback. DO NOT EDIT.
+// Minimal shim for google/protobuf/empty.proto when protoc output isn't available.
+
+export class Empty {
+  static encode(...args: any): any {
+    return [];
+  }
+
+  static decode(...args: any): Empty {
+    return {} as any;
+  }
+}