zylaris 1.0.2

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

@@ -0,0 +1,274 @@
+/**
+ * Netlify Adapter (Functions + Edge)
+ * Supports: Netlify 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 netlifyAdapter: Adapter = {
+  name: 'netlify',
+  target: 'netlify',
+
+  async build(config: AdapterConfig): Promise<BuildResult> {
+    const outDir = path.resolve(config.outDir || 'dist');
+    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 });
+
+      // Netlify output structure
+      const functionsDir = path.join(outDir, 'netlify', 'functions');
+      const edgeFunctionsDir = path.join(outDir, 'netlify', 'edge-functions');
+      const publishDir = outDir;
+
+      await fs.mkdir(functionsDir, { recursive: true });
+      await fs.mkdir(edgeFunctionsDir, { recursive: true });
+
+      // Build client bundle
+      const { files: clientFiles } = await buildClient(config, publishDir);
+
+      // Copy public assets
+      await copyPublic(publishDir);
+
+      // Build function
+      if (isEdge) {
+        await buildEdgeFunction(config, edgeFunctionsDir);
+      } else {
+        await buildNetlifyFunction(config, functionsDir);
+      }
+
+      // Generate config files
+      await generateNetlifyConfig(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] = `/_assets/${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 = 8888): Promise<void> {
+    const { execSync } = await import('child_process');
+    
+    console.log('Starting Netlify dev server...');
+    execSync(`npx netlify dev --port ${port}`, { stdio: 'inherit' });
+  },
+
+  async deploy(_config: AdapterConfig): Promise<void> {
+    const { execSync } = await import('child_process');
+    
+    console.log('Deploying to Netlify...');
+    execSync('npx netlify deploy --prod', { stdio: 'inherit' });
+  }
+};
+
+/** Build Netlify Edge Function */
+async function buildEdgeFunction(_config: AdapterConfig, edgeFunctionsDir: string): Promise<void> {
+  const entryContent = `
+import type { Config } from "@netlify/edge-functions";
+import { handleRequest } from '@zylaris/server/edge';
+
+export default async function handler(request: Request) {
+  return handleRequest(request, {
+    // App configuration
+  });
+}
+
+export const config: Config = {
+  path: "/*",
+  cache: "manual",
+};
+`;
+
+  await fs.writeFile(path.join(edgeFunctionsDir, 'zylaris-app.ts'), entryContent);
+
+  // Build the edge function
+  const { build } = await import('esbuild');
+  await build({
+    entryPoints: [path.join(edgeFunctionsDir, 'zylaris-app.ts')],
+    bundle: true,
+    format: 'esm',
+    platform: 'neutral',
+    target: 'es2022',
+    outfile: path.join(edgeFunctionsDir, 'zylaris-app.js'),
+    external: ['@netlify/edge-functions'],
+    minify: true,
+  });
+}
+
+/** Build Netlify Function */
+async function buildNetlifyFunction(config: AdapterConfig, functionsDir: string): Promise<void> {
+  const functionName = config.function?.name || 'zylaris-app';
+  
+  // Build server bundle
+  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: 'esm',
+    platform: 'node',
+    target: 'node18',
+    outfile: path.join(functionsDir, `${functionName}.js`),
+    external: ['@zylaris/*'],
+    minify: true,
+  });
+}
+
+/** Generate Netlify config files */
+async function generateNetlifyConfig(
+  config: AdapterConfig, 
+  outDir: string,
+  isEdge: boolean
+): Promise<void> {
+  // netlify.toml
+  const redirects = config.redirects?.map(r => ({
+    from: r.from,
+    to: r.to,
+    status: r.status || 301,
+  })) || [];
+
+  const headers = Object.entries(config.headers || {}).map(([path, header]) => ({
+    for: path,
+    values: Object.fromEntries(header.split(':').map((h, i, arr) => 
+      i === 0 ? [] : [arr[0].trim(), h.trim()]
+    ).filter(Boolean)),
+  }));
+
+  const netlifyConfig = {
+    build: {
+      publish: outDir,
+      command: 'echo "Build already done"',
+    },
+    functions: {
+      directory: 'netlify/functions',
+    },
+    'edge-functions': isEdge ? [
+      {
+        path: '/*',
+        function: 'zylaris-app',
+      }
+    ] : undefined,
+    redirects: [
+      ...redirects,
+      // SPA fallback
+      { from: '/*', to: '/index.html', status: 200 },
+    ],
+    headers,
+  };
+
+  // Write as TOML-like format (simplified)
+  const tomlContent = generateToml(netlifyConfig);
+  await fs.writeFile('netlify.toml', tomlContent);
+
+  // _redirects file
+  const redirectsContent = [
+    ...redirects.map(r => `${r.from} ${r.to} ${r.status}`),
+    '/* /index.html 200',
+  ].join('\n');
+  
+  await fs.writeFile(path.join(outDir, '_redirects'), redirectsContent);
+}
+
+/** Simple TOML generator */
+function generateToml(obj: Record<string, unknown>, prefix = ''): string {
+  let result = '';
+  
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined) continue;
+    
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === 'object') {
+          result += `[[${prefix}${key}]]\n`;
+          result += generateToml(item as Record<string, unknown>);
+        }
+      }
+    } else if (typeof value === 'object') {
+      result += `[${prefix}${key}]\n`;
+      result += generateToml(value as Record<string, unknown>);
+    } else {
+      result += `${key} = ${JSON.stringify(value)}\n`;
+    }
+  }
+  
+  return result;
+}
+
+/** 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 netlifyAdapter;

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

@@ -0,0 +1,155 @@
+/**
+ * Node.js Server Adapter
+ * For: Traditional Node.js hosting, VPS, Docker, PM2
+ */
+
+import * as fs from 'fs/promises';
+import path from 'path';
+import type { Adapter, AdapterConfig, BuildResult, RouteManifest } from '../types.js';
+import { 
+  buildClient, 
+  buildServer,
+  generateManifest,
+  copyPublic,
+  analyzeBundle
+} from '../lib/builder.js';
+
+export const nodeAdapter: Adapter = {
+  name: 'node',
+  target: 'node',
+
+  async build(config: AdapterConfig): Promise<BuildResult> {
+    const outDir = path.resolve(config.outDir || 'dist');
+    const warnings: string[] = [];
+    const errors: string[] = [];
+
+    try {
+      // Clean output directory
+      await fs.rm(outDir, { recursive: true, force: true });
+      await fs.mkdir(outDir, { recursive: true });
+
+      // Build client bundle
+      const { files: clientFiles } = await buildClient(config, outDir);
+
+      // Build server bundle
+      const { files: serverFiles, entry: serverEntry } = await buildServer(config, outDir, 'node');
+
+      // Copy public assets
+      await copyPublic(outDir);
+
+      // Generate server entry file
+      await generateServerEntry(config, outDir, serverEntry);
+
+      // Generate package.json for production
+      await generatePackageJson(outDir);
+
+      // 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] = `/_assets/${basename}`;
+      }
+
+      await generateManifest(config, outDir, routes, assets);
+
+      // Analyze bundle
+      const analysis = await analyzeBundle(outDir);
+
+      return {
+        success: true,
+        outDir,
+        files: [...clientFiles, ...serverFiles],
+        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 outDir = path.resolve(config.outDir || 'dist');
+    const entryPath = path.join(outDir, 'index.js');
+
+    // Set port environment variable
+    process.env.PORT = String(port);
+    
+    // Import and run server
+    await import(entryPath);
+
+    return new Promise(() => {}); // Keep running
+  }
+};
+
+/** Generate server entry point */
+async function generateServerEntry(
+  _config: AdapterConfig, 
+  outDir: string,
+  serverEntry: string
+): Promise<void> {
+  const port = process.env.PORT || 3000;
+  const host = process.env.HOST || '0.0.0.0';
+
+  const entryContent = `#!/usr/bin/env node
+import { createServer } from '@zylaris/server';
+import { handler } from './server/${path.basename(serverEntry)}';
+
+const port = process.env.PORT || ${port};
+const host = process.env.HOST || '${host}';
+
+const server = createServer({
+  handler,
+  port: Number(port),
+  host,
+  static: './client',
+  compress: true,
+});
+
+console.log(\`🚀 Server running at http://\${host}:\${port}\`);
+`;
+
+  await fs.writeFile(path.join(outDir, 'index.js'), entryContent);
+  
+  // Make executable (Unix)
+  try {
+    await fs.chmod(path.join(outDir, 'index.js'), 0o755);
+  } catch {
+    // Ignore on Windows
+  }
+}
+
+/** Generate production package.json */
+async function generatePackageJson(outDir: string): Promise<void> {
+  const pkg = {
+    name: 'zylaris-app',
+    version: '1.0.0',
+    type: 'module',
+    scripts: {
+      start: 'node index.js',
+    },
+    dependencies: {
+      '@zylaris/server': 'workspace:*',
+    },
+    engines: {
+      node: '>=18.0.0',
+    },
+  };
+
+  await fs.writeFile(path.join(outDir, 'package.json'), JSON.stringify(pkg, null, 2));
+}
+
+export default nodeAdapter;

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

@@ -0,0 +1,134 @@
+/**
+ * Static Site Generator Adapter
+ * For: GitHub Pages, Netlify Static, Vercel Static, Cloudflare Pages, Surge, etc.
+ */
+
+import * as fs from 'fs/promises';
+import path from 'path';
+import type { Adapter, AdapterConfig, BuildResult, RouteManifest } from '../types.js';
+import { 
+  buildClient, 
+  generateStaticPages, 
+  generateManifest,
+  copyPublic,
+  generateHeaders,
+  generateRedirects,
+  analyzeBundle
+} from '../lib/builder.js';
+
+export const staticAdapter: Adapter = {
+  name: 'static',
+  target: 'static',
+
+  async build(config: AdapterConfig): Promise<BuildResult> {
+    const outDir = path.resolve(config.outDir || 'dist');
+    const warnings: string[] = [];
+    const errors: string[] = [];
+
+    try {
+      // Clean output directory
+      await fs.rm(outDir, { recursive: true, force: true });
+      await fs.mkdir(outDir, { recursive: true });
+
+      // Build client bundle
+      const { files: clientFiles } = await buildClient(config, outDir);
+
+      // Generate static pages
+      await generateStaticPages(config, outDir, clientFiles);
+
+      // Copy public assets
+      await copyPublic(outDir);
+
+      // Generate platform config files
+      await generatePlatformFiles(config, outDir);
+
+      // 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] = `/_assets/${basename}`;
+      }
+
+      await generateManifest(config, outDir, routes, assets);
+
+      // Analyze bundle
+      const analysis = await analyzeBundle(outDir);
+
+      // List 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 = 4173): Promise<void> {
+    console.log('Preview is not implemented yet for static adapter.');
+  }
+};
+
+/** Generate platform-specific files */
+async function generatePlatformFiles(config: AdapterConfig, outDir: string): Promise<void> {
+  // Generate _headers for Netlify/Cloudflare
+  await generateHeaders(config, outDir);
+
+  // Generate _redirects
+  await generateRedirects(config, outDir);
+
+  // Generate SPA fallback for client-side routing
+  if (config.static?.fallback) {
+    const fallbackHtml = `<!DOCTYPE html>
+<html>
+<head>
+    <meta http-equiv="refresh" content="0;url=${config.static.fallback}">
+</head>
+<body></body>
+</html>`;
+    await fs.writeFile(path.join(outDir, '404.html'), fallbackHtml);
+  }
+
+  // Generate .nojekyll for GitHub Pages
+  await fs.writeFile(path.join(outDir, '.nojekyll'), '');
+}
+
+/** 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 staticAdapter;