zylaris 1.0.2

package/packages/adapter/src/adapters/vercel.ts

@@ -0,0 +1,239 @@
+/**
+ * Vercel Adapter (Serverless + Edge)
+ * Supports: Vercel Serverless Functions & Edge Functions
+ */
+
+import * as fs from 'fs/promises';
+import path from 'path';
+import type { Adapter, AdapterConfig, BuildResult, RouteManifest } from '../types.js';
+import { 
+  buildClient, 
+  generateManifest,
+  copyPublic,
+  analyzeBundle
+} from '../lib/builder.js';
+
+export const vercelAdapter: Adapter = {
+  name: 'vercel',
+  target: 'vercel',
+
+  async build(config: AdapterConfig): Promise<BuildResult> {
+    const outDir = path.resolve(config.outDir || '.vercel/output');;
+    const isEdge = config.function?.edge ?? false;
+    const warnings: string[] = [];
+    const errors: string[] = [];
+
+    try {
+      // Clean output directory
+      await fs.rm(outDir, { recursive: true, force: true });
+      await fs.mkdir(outDir, { recursive: true });
+
+      // Vercel output structure
+      const staticDir = path.join(outDir, 'static');
+      const functionsDir = path.join(outDir, 'functions');
+      
+      await fs.mkdir(staticDir, { recursive: true });
+      await fs.mkdir(functionsDir, { recursive: true });
+
+      // Build client bundle
+      const { files: clientFiles } = await buildClient(config, staticDir);
+
+      // Copy public assets
+      await copyPublic(staticDir);
+
+      // Build server function
+      if (isEdge) {
+        await buildEdgeFunction(config, functionsDir);
+      } else {
+        await buildServerlessFunction(config, functionsDir);
+      }
+
+      // Generate config files
+      await generateVercelConfig(config, outDir, isEdge);
+
+      // Generate manifest
+      const routes: RouteManifest[] = (config.static?.routes || ['/']).map(route => ({
+        path: route,
+        file: route === '/' ? 'index.html' : `${route}.html`,
+      }));
+
+      const assets: Record<string, string> = {};
+      for (const file of clientFiles) {
+        const basename = path.basename(file);
+        assets[basename] = `/${basename}`;
+      }
+
+      await generateManifest(config, outDir, routes, assets);
+
+      // Analyze bundle
+      const analysis = await analyzeBundle(outDir);
+
+      // List all output files
+      const allFiles = await listFiles(outDir);
+
+      return {
+        success: true,
+        outDir,
+        files: allFiles,
+        warnings,
+        errors,
+        analysis,
+      };
+
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+      return {
+        success: false,
+        outDir,
+        files: [],
+        warnings,
+        errors,
+      };
+    }
+  },
+
+  async preview(_config: AdapterConfig, port = 3000): Promise<void> {
+    const { execSync } = await import('child_process');
+    
+    console.log('Starting Vercel dev server...');
+    execSync(`npx vercel dev --port ${port}`, { stdio: 'inherit' });
+  },
+
+  async deploy(_config: AdapterConfig): Promise<void> {
+    const { execSync } = await import('child_process');
+    
+    console.log('Deploying to Vercel...');
+    execSync('npx vercel --prod', { stdio: 'inherit' });
+  }
+};
+
+/** Build Vercel Edge Function */
+async function buildEdgeFunction(config: AdapterConfig, functionsDir: string): Promise<void> {
+  const functionDir = path.join(functionsDir, 'api');
+  await fs.mkdir(functionDir, { recursive: true });
+
+  const entryContent = `
+import { handleRequest } from '@zylaris/server/edge';
+
+export const config = {
+  runtime: 'edge',
+  regions: ${JSON.stringify(config.function?.regions || ['iad1'])},
+};
+
+export default async function handler(request) {
+  return handleRequest(request, {
+    // App configuration
+  });
+}
+`;
+
+  // Build edge function
+  const { build } = await import('esbuild');
+  await build({
+    stdin: {
+      contents: entryContent,
+      resolveDir: process.cwd(),
+    },
+    bundle: true,
+    format: 'esm',
+    platform: 'neutral',
+    target: 'es2022',
+    outfile: path.join(functionDir, 'index.js'),
+    external: ['node:*'],
+    minify: true,
+  });
+}
+
+/** Build Vercel Serverless Function */
+async function buildServerlessFunction(config: AdapterConfig, functionsDir: string): Promise<void> {
+  const functionDir = path.join(functionsDir, 'api');
+  await fs.mkdir(functionDir, { recursive: true });
+
+  // Build server bundle for Node.js
+  const { build } = await import('esbuild');
+  
+  const possibleEntries = ['./src/entry-server.ts', './src/entry-server.tsx'];
+  const entryPoints: string[] = [];
+  for (const e of possibleEntries) {
+    try {
+      await fs.access(e);
+      entryPoints.push(e);
+    } catch {
+      // skip
+    }
+  }
+  
+  await build({
+    entryPoints,
+    bundle: true,
+    format: 'cjs', // Serverless uses CommonJS
+    platform: 'node',
+    target: 'node18',
+    outfile: path.join(functionDir, 'index.js'),
+    external: ['@zylaris/*'],
+    minify: true,
+  });
+
+  // Create function config
+  const funcConfig = {
+    maxDuration: config.function?.timeout || 10,
+    memory: config.function?.memory || 1024,
+  };
+  
+  await fs.writeFile(path.join(functionDir, '.vc-config.json'), JSON.stringify(funcConfig, null, 2));
+}
+
+/** Generate Vercel config files */
+async function generateVercelConfig(
+  _config: AdapterConfig, 
+  outDir: string,
+  isEdge: boolean
+): Promise<void> {
+  // config.json
+  const vercelConfig = {
+    version: 3,
+    routes: [
+      // API routes
+      { src: '/api/(.*)', dest: '/api' },
+      // Static assets
+      { src: '/_assets/(.*)', headers: { 'cache-control': 'public, max-age=31536000, immutable' } },
+      // SPA fallback
+      { handle: 'filesystem' },
+      { src: '/(.*)', dest: isEdge ? '/api' : '/index.html' },
+    ],
+  };
+
+  await fs.writeFile(path.join(outDir, 'config.json'), JSON.stringify(vercelConfig, null, 2));
+
+  // Project config (for CLI)
+  const projectConfig = {
+    buildCommand: null,
+    outputDirectory: '.vercel/output',
+    framework: null,
+    installCommand: null,
+  };
+
+  await fs.mkdir('.vercel', { recursive: true });
+  await fs.writeFile('.vercel/project.json', JSON.stringify(projectConfig, null, 2));
+}
+
+/** List all files recursively */
+async function listFiles(dir: string, prefix = ''): Promise<string[]> {
+  const files: string[] = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+    if ((entry as { isDirectory(): boolean }).isDirectory()) {
+      files.push(...await listFiles(fullPath, relativePath));
+    } else {
+      files.push(relativePath);
+    }
+  }
+
+  return files;
+}
+
+export default vercelAdapter;

package/packages/adapter/src/index.ts

@@ -0,0 +1,115 @@
+/**
+ * Zylaris Adapter - Universal deployment for every hosting platform
+ * 
+ * Supported Platforms:
+ * - Static: GitHub Pages, Surge.sh, AWS S3, etc.
+ * - Node.js: VPS, Docker, PM2, Railway, Render
+ * - Vercel: Serverless + Edge Functions
+ * - Netlify: Functions + Edge Functions
+ * - Cloudflare: Pages + Workers
+ * - Deno: Deno Deploy
+ * - Bun: Bun runtime
+ */
+
+export type {
+  Adapter,
+  AdapterConfig,
+  BuildResult,
+  DeploymentTarget,
+  DeploymentManifest,
+  RouteManifest,
+  FunctionConfig,
+  StaticOptions,
+  RequestHandler,
+  EdgeContext,
+  PlatformConfig,
+} from './types.js';
+
+// Adapters
+export { staticAdapter } from './adapters/static.js';
+export { nodeAdapter } from './adapters/node.js';
+export { vercelAdapter } from './adapters/vercel.js';
+export { netlifyAdapter } from './adapters/netlify.js';
+export { cloudflareAdapter } from './adapters/cloudflare.js';
+export { denoAdapter } from './adapters/deno.js';
+export { bunAdapter } from './adapters/bun.js';
+
+import type { Adapter, DeploymentTarget } from './types.js';
+import { staticAdapter } from './adapters/static.js';
+import { nodeAdapter } from './adapters/node.js';
+import { vercelAdapter } from './adapters/vercel.js';
+import { netlifyAdapter } from './adapters/netlify.js';
+import { cloudflareAdapter } from './adapters/cloudflare.js';
+import { denoAdapter } from './adapters/deno.js';
+import { bunAdapter } from './adapters/bun.js';
+
+/** Map of all adapters */
+export const adapters: Record<DeploymentTarget, Adapter> = {
+  static: staticAdapter,
+  node: nodeAdapter,
+  vercel: vercelAdapter,
+  netlify: netlifyAdapter,
+  cloudflare: cloudflareAdapter,
+  deno: denoAdapter,
+  bun: bunAdapter,
+};
+
+/** Get adapter by target */
+export function getAdapter(target: DeploymentTarget): Adapter {
+  const adapter = adapters[target];
+  if (!adapter) {
+    throw new Error(`Unknown adapter target: ${target}. Available: ${Object.keys(adapters).join(', ')}`);
+  }
+  return adapter;
+}
+
+/** List all available adapters */
+export function listAdapters(): Array<{ target: DeploymentTarget; name: string; description: string }> {
+  return [
+    { 
+      target: 'static', 
+      name: 'Static', 
+      description: 'GitHub Pages, Surge.sh, AWS S3, Cloudflare Pages Static, Netlify Static' 
+    },
+    { 
+      target: 'node', 
+      name: 'Node.js', 
+      description: 'VPS, Docker, PM2, Railway, Render, traditional Node.js hosting' 
+    },
+    { 
+      target: 'vercel', 
+      name: 'Vercel', 
+      description: 'Vercel Serverless Functions & Edge Functions' 
+    },
+    { 
+      target: 'netlify', 
+      name: 'Netlify', 
+      description: 'Netlify Functions & Edge Functions' 
+    },
+    { 
+      target: 'cloudflare', 
+      name: 'Cloudflare', 
+      description: 'Cloudflare Pages & Workers' 
+    },
+    { 
+      target: 'deno', 
+      name: 'Deno', 
+      description: 'Deno Deploy edge runtime' 
+    },
+    { 
+      target: 'bun', 
+      name: 'Bun', 
+      description: 'Bun runtime (experimental)' 
+    },
+  ];
+}
+
+/** Check if adapter supports SSR */
+export function supportsSSR(target: DeploymentTarget): boolean {
+  return target !== 'static';
+}
+
+/** Check if adapter supports Edge runtime */
+export function supportsEdge(target: DeploymentTarget): boolean {
+  return ['vercel', 'netlify', 'cloudflare', 'deno'].includes(target);
+}

package/packages/adapter/src/lib/builder.ts

@@ -0,0 +1,361 @@
+/**
+ * Universal build utilities for all adapters
+ */
+
+import { build } from 'esbuild';
+import * as fs from 'fs/promises';
+import path from 'path';
+import { createHash } from 'crypto';
+
+/** Check if path exists */
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await fs.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+import type { 
+  AdapterConfig, 
+  BuildResult, 
+  DeploymentManifest,
+  RouteManifest 
+} from '../types.js';
+
+/** Recursively copy directory */
+async function copyDir(src: string, dest: string): Promise<void> {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(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()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+
+/** Default build options */
+const defaultBuildOptions = {
+  bundle: true,
+  splitting: true,
+  format: 'esm' as const,
+  target: 'es2022',
+  minify: true,
+  sourcemap: true,
+  treeShaking: true,
+};
+
+/** Build client bundle */
+export async function buildClient(
+  config: AdapterConfig,
+  outDir: string
+): Promise<{ files: string[]; size: number }> {
+  const clientDir = path.join(outDir, 'client');
+  await fs.mkdir(clientDir, { recursive: true });
+
+  const possibleEntries = ['./src/entry-client.tsx', './src/entry-client.ts', './src/main.tsx', './src/main.ts'];
+  const existingEntries: string[] = [];
+  for (const e of possibleEntries) {
+    try {
+      await fs.access(e);
+      existingEntries.push(e);
+    } catch {
+      // skip
+    }
+  }
+  const entryPoints = config.entry 
+    ? [config.entry]
+    : existingEntries;
+
+  if (entryPoints.length === 0) {
+    throw new Error('No client entry point found');
+  }
+
+  const result = await build({
+    ...defaultBuildOptions,
+    ...config.esbuild,
+    entryPoints,
+    outdir: clientDir,
+    platform: 'browser',
+    splitting: true,
+    format: 'esm',
+    metafile: true,
+    define: {
+      'process.env.NODE_ENV': '"production"',
+      'import.meta.env.SSR': 'false',
+      ...config.esbuild?.define,
+    },
+  });
+
+  const files = Object.keys(result.metafile?.outputs || {});
+  const totalSize = files.reduce((sum, f) => sum + (result.metafile?.outputs[f]?.bytes || 0), 0);
+
+  return { files, size: totalSize };
+}
+
+/** Build server bundle */
+export async function buildServer(
+  config: AdapterConfig,
+  outDir: string,
+  platform: 'node' | 'neutral' = 'node'
+): Promise<{ files: string[]; size: number; entry: string }> {
+  const serverDir = path.join(outDir, 'server');
+  await fs.mkdir(serverDir, { recursive: true });
+
+  const possibleEntries = ['./src/entry-server.tsx', './src/entry-server.ts'];
+  const entryPoints: string[] = [];
+  for (const e of possibleEntries) {
+    try {
+      await fs.access(e);
+      entryPoints.push(e);
+    } catch {
+      // skip
+    }
+  }
+
+  if (entryPoints.length === 0) {
+    throw new Error('No server entry point found');
+  }
+
+  const result = await build({
+    ...defaultBuildOptions,
+    ...config.esbuild,
+    entryPoints,
+    outdir: serverDir,
+    platform,
+    splitting: false,
+    format: 'esm',
+    metafile: true,
+    external: ['node:*', ...Object.keys((await getPackageJson()).dependencies || {})],
+    define: {
+      'process.env.NODE_ENV': '"production"',
+      'import.meta.env.SSR': 'true',
+      ...config.esbuild?.define,
+    },
+  });
+
+  const files = Object.keys(result.metafile?.outputs || {});
+  const entry = files.find(f => !f.endsWith('.map')) || files[0];
+  const totalSize = files.reduce((sum, f) => sum + (result.metafile?.outputs[f]?.bytes || 0), 0);
+
+  return { files, size: totalSize, entry };
+}
+
+/** Generate static pages */
+export async function generateStaticPages(
+  config: AdapterConfig,
+  outDir: string,
+  clientFiles: string[]
+): Promise<string[]> {
+  const staticDir = path.join(outDir, 'static');
+  await fs.mkdir(staticDir, { recursive: true });
+
+  const routes = config.static?.routes || ['/'];
+  const generated: string[] = [];
+
+  // Generate HTML for each route
+  for (const route of routes) {
+    const html = await renderRoute(route, clientFiles, config);
+    const filePath = routeToFilePath(route, config);
+    const fullPath = path.join(staticDir, filePath);
+    
+    await fs.mkdir(path.dirname(fullPath), { recursive: true });
+    await fs.writeFile(fullPath, html);
+    generated.push(filePath);
+  }
+
+  // Copy client assets
+  const clientDir = path.join(outDir, 'client');
+  if (await pathExists(clientDir)) {
+    await copyDir(clientDir, path.join(staticDir, '_assets'));
+  }
+
+  return generated;
+}
+
+/** Render a route to HTML */
+async function renderRoute(
+  _route: string,
+  clientFiles: string[],
+  config: AdapterConfig
+): Promise<string> {
+  const jsFiles = clientFiles.filter(f => f.endsWith('.js'));
+  const cssFiles = clientFiles.filter(f => f.endsWith('.css'));
+  const base = config.static?.base || '';
+
+  const jsTags = jsFiles
+    .map(f => `<script type="module" src="${base}/_assets/${path.basename(f)}"></script>`)
+    .join('\n    ');
+
+  const cssTags = cssFiles
+    .map(f => `<link rel="stylesheet" href="${base}/_assets/${path.basename(f)}">`)
+    .join('\n    ');
+
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Zylaris App</title>
+    ${cssTags}
+</head>
+<body>
+    <div id="app"></div>
+    ${jsTags}
+</body>
+</html>`;
+}
+
+/** Convert route to file path */
+function routeToFilePath(route: string, config: AdapterConfig): string {
+  const cleanUrls = config.cleanUrls ?? true;
+  const trailingSlash = config.trailingSlash ?? 'ignore';
+
+  let path = route === '/' ? '/index' : route;
+  
+  if (trailingSlash === 'always' && !path.endsWith('/')) {
+    path += '/';
+  }
+  
+  if (cleanUrls) {
+    return path + (path.endsWith('/') ? 'index.html' : '.html');
+  }
+  
+  return path + '.html';
+}
+
+/** Generate deployment manifest */
+export async function generateManifest(
+  _config: AdapterConfig,
+  outDir: string,
+  routes: RouteManifest[],
+  assets: Record<string, string>
+): Promise<void> {
+  const manifest: DeploymentManifest = {
+    version: '0.1.0',
+    timestamp: new Date().toISOString(),
+    routes,
+    assets,
+    entry: {
+      client: '/_assets/entry-client.js',
+    },
+  };
+
+  await fs.writeFile(
+    path.join(outDir, 'manifest.json'),
+    JSON.stringify(manifest, null, 2)
+  );
+}
+
+/** Copy public directory */
+export async function copyPublic(outDir: string): Promise<void> {
+  if (await pathExists('public')) {
+    await copyDir('public', outDir);
+  }
+}
+
+/** Generate HTTP headers file */
+export async function generateHeaders(
+  config: AdapterConfig,
+  outDir: string
+): Promise<void> {
+  if (!config.headers) return;
+
+  const headersFile = Object.entries(config.headers)
+    .map(([pattern, header]) => `${pattern}\n  ${header}`)
+    .join('\n');
+
+  await fs.writeFile(path.join(outDir, '_headers'), headersFile);
+}
+
+/** Generate redirects file */
+export async function generateRedirects(
+  config: AdapterConfig,
+  outDir: string
+): Promise<void> {
+  if (!config.redirects?.length) return;
+
+  const redirects = config.redirects
+    .map(r => `${r.from} ${r.to} ${r.status || 301}`)
+    .join('\n');
+
+  await fs.writeFile(path.join(outDir, '_redirects'), redirects);
+}
+
+/** Get package.json */
+async function getPackageJson(): Promise<{ dependencies?: Record<string, string> }> {
+  try {
+    const content = await fs.readFile('package.json', 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+/** Create hash for cache busting */
+export function createContentHash(content: string, length = 8): string {
+  return createHash('md5').update(content).digest('hex').slice(0, length);
+}
+
+/** Calculate gzip size */
+export async function calculateGzipSize(filePath: string): Promise<number> {
+  const { gzipSync } = await import('zlib');
+  const content = await fs.readFile(filePath);
+  return gzipSync(content).length;
+  return gzipSync(content).length;
+}
+
+/** Analyze bundle output */
+export async function analyzeBundle(
+  outDir: string
+): Promise<BuildResult['analysis']> {
+  const clientDir = path.join(outDir, 'client');
+  const serverDir = path.join(outDir, 'server');
+  
+  let totalSize = 0;
+  let clientSize = 0;
+  let serverSize = 0;
+  const assets: Array<{ file: string; size: number; gzip: number }> = [];
+
+  // Analyze client assets
+  if (await pathExists(clientDir)) {
+    const files = await fs.readdir(clientDir, { recursive: true }) as string[];
+    for (const file of files.filter((f: string) => !f.endsWith('.map'))) {
+      const filePath = path.join(clientDir, file);
+      const stats = await fs.stat(filePath);
+      if (stats.isFile()) {
+        const size = stats.size;
+        const gzip = await calculateGzipSize(filePath);
+        totalSize += size;
+        clientSize += size;
+        assets.push({ file: `client/${file}`, size, gzip });
+      }
+    }
+  }
+
+  // Analyze server assets
+  if (await pathExists(serverDir)) {
+    const files = await fs.readdir(serverDir, { recursive: true }) as string[];
+    for (const file of files.filter((f: string) => !f.endsWith('.map'))) {
+      const filePath = path.join(serverDir, file);
+      const stats = await fs.stat(filePath);
+      if (stats.isFile()) {
+        const size = stats.size;
+        serverSize += size;
+        totalSize += size;
+      }
+    }
+  }
+
+  return {
+    totalSize,
+    clientSize,
+    serverSize,
+    assets: assets.sort((a, b) => b.size - a.size),
+  };
+}