bundled templates approach

Author: eluce2

apps/docs/.gitignore

@@ -25,4 +25,7 @@ yarn-error.log*
 # others
 .env*.local
 .vercel
-next-env.d.ts
+next-env.d.ts
+
+# Registry build artifacts
+public/registry-templates/

apps/docs/package.json

@@ -3,7 +3,7 @@
   "version": "0.0.2",
   "private": true,
   "scripts": {
-    "build": "next build",
+    "build": "node scripts/bundle-registry-templates.js && next build",
     "dev": "next dev -p 3005 --turbo",
     "start": "next start",
     "postinstall": "fumadocs-mdx",

apps/docs/scripts/bundle-registry-templates.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * This script copies registry template files into the Next.js build
+ * so they're available as static assets in serverless environments
+ */
+
+async function bundleRegistryTemplates() {
+  console.log('📦 Bundling registry templates...');
+  
+  try {
+    // Source: registry package templates
+    const registryPath = path.resolve(__dirname, '../../../packages/registry/templates');
+    
+    // Destination: Next.js public directory (served as static assets)
+    const publicRegistryPath = path.resolve(__dirname, '../public/registry-templates');
+    
+    // Clean and create destination directory
+    if (fs.existsSync(publicRegistryPath)) {
+      fs.rmSync(publicRegistryPath, { recursive: true });
+    }
+    fs.mkdirSync(publicRegistryPath, { recursive: true });
+    
+    // Copy all template files
+    copyDirectory(registryPath, publicRegistryPath);
+    
+    console.log('✅ Registry templates bundled successfully!');
+    console.log(`📁 Templates available at: ${publicRegistryPath}`);
+    
+    // Also create a manifest of all available templates
+    const manifest = createTemplateManifest(publicRegistryPath);
+    fs.writeFileSync(
+      path.join(publicRegistryPath, 'manifest.json'),
+      JSON.stringify(manifest, null, 2)
+    );
+    
+    console.log(`📋 Template manifest created with ${manifest.templates.length} templates`);
+    
+  } catch (error) {
+    console.error('❌ Failed to bundle registry templates:', error);
+    process.exit(1);
+  }
+}
+
+function copyDirectory(src, dest) {
+  if (!fs.existsSync(src)) {
+    throw new Error(`Source directory does not exist: ${src}`);
+  }
+  
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    
+    if (entry.isDirectory()) {
+      fs.mkdirSync(destPath, { recursive: true });
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function createTemplateManifest(templatesPath) {
+  const templates = [];
+  
+  function scanDirectory(dir, relativePath = '') {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relPath = path.join(relativePath, entry.name);
+      
+      if (entry.isDirectory()) {
+        scanDirectory(fullPath, relPath);
+      } else if (entry.name === '_meta.ts') {
+        // Found a template directory
+        const templatePath = relativePath || '.';
+        templates.push({
+          name: templatePath.replace(/\\/g, '/'), // normalize path separators
+          path: templatePath,
+          metaFile: relPath.replace(/\\/g, '/'),
+        });
+      }
+    }
+  }
+  
+  scanDirectory(templatesPath);
+  
+  return {
+    generatedAt: new Date().toISOString(),
+    templates,
+  };
+}
+
+bundleRegistryTemplates();

apps/docs/src/app/r/[[...name]]/route.ts

@@ -1,36 +1,52 @@
-import { handle } from "hono/vercel";
-import app from "./registry";
-import { getRegistryIndex } from "@proofkit/registry";
+import { NextRequest } from 'next/server';
+import { 
+  getRegistryIndex, 
+  getComponentMeta, 
+  getStaticComponentForShadcn 
+} from '@/lib/registry-server';
 
-const handler = handle(app);
-export {
-  handler as GET,
-};
-
-export const dynamicParams = false
-
-// Generate static params for all registry routes
-export async function generateStaticParams() {
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ name?: string[] }> }
+) {
   try {
-    const index = await getRegistryIndex();
+    const { name = [] } = await params;
+    const path = name.join('/');
+    const url = new URL(request.url);
+    
+    // Handle root registry request
+    if (path === '') {
+      const index = await getRegistryIndex();
+      return Response.json(index);
+    }
+    
+    // Handle meta requests
+    if (path.startsWith('meta/')) {
+      const componentPath = path.replace('meta/', '');
+      const meta = await getComponentMeta(componentPath);
+      return Response.json(meta);
+    }
+    
+    // Handle component requests
+    const routeNameRaw = url.searchParams.get('routeName');
+    const routeName = routeNameRaw ? routeNameRaw.replace(/^\/+/, '') : undefined;
+    
+    const component = await getStaticComponentForShadcn(path, { routeName });
 
-    const params = [
-      // Root registry route
-      { name: [] },
-      // Individual component routes
-      ...index.map((item) => ({
-        name: item.name.split('/'),
-      })),
-      // Meta routes for each component
-      ...index.map((item) => ({
-        name: ['meta', ...item.name.split('/')],
-      })),
-    ];
+    // Replace {proofkit} placeholders with the current origin
+    const responseData = {
+      ...component,
+      registryDependencies: component.registryDependencies?.map((dep: string) =>
+        dep.replace('{proofkit}', url.origin)
+      ),
+    };
 
-    console.log('Generated static params for registry:', params);
-    return params;
+    return Response.json(responseData);
   } catch (error) {
-    console.error('Failed to generate static params for registry:', error);
-    return [{ name: [] }];
+    console.error('Registry route error:', error);
+    return Response.json(
+      { error: 'Component not found.' },
+      { status: 404 }
+    );
   }
 }