zylaris 1.0.2

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

@@ -0,0 +1,215 @@
+/**
+ * Bun Adapter
+ * For: Bun runtime and Bun deploy
+ */
+
+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 bunAdapter: Adapter = {
+  name: 'bun',
+  target: 'bun',
+
+  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);
+
+      // Copy public assets
+      await copyPublic(outDir);
+
+      // Build Bun server entry
+      await buildBunEntry(config, outDir);
+
+      // Generate config files
+      await generateBunConfig(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] = `/${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 { spawn } = await import('child_process');
+    const outDir = path.resolve(config.outDir || 'dist');
+    
+    console.log('Starting Bun server...');
+    const proc = spawn('bun', [path.join(outDir, 'server.js')], {
+      stdio: 'inherit',
+      env: { ...process.env, PORT: String(port) }
+    });
+
+    return new Promise((resolve, reject) => {
+      proc.on('error', reject);
+      proc.on('exit', resolve);
+    });
+  },
+
+  async deploy(config: AdapterConfig): Promise<void> {
+    console.log('Deploying with Bun...');
+    // Bun doesn't have a native deploy yet, but we can use Docker or other methods
+    console.log('For Bun Deploy, consider using Docker or a VPS with Bun installed.');
+    console.log('Build output is in:', config.outDir || 'dist');
+  }
+};
+
+/** Build Bun server entry */
+async function buildBunEntry(_config: AdapterConfig, outDir: string): Promise<void> {
+  const serverContent = `
+import { serve } from "bun";
+
+const port = parseInt(process.env.PORT || "3000");
+const hostname = process.env.HOST || "0.0.0.0";
+
+serve({
+  port,
+  hostname,
+  async fetch(request) {
+    const url = new URL(request.url);
+    const pathname = url.pathname;
+    
+    // Static assets
+    if (pathname.startsWith("/_assets/")) {
+      const file = Bun.file(pathname.slice(1));
+      if (await file.exists()) {
+        return new Response(file, {
+          headers: {
+            "cache-control": "public, max-age=31536000, immutable",
+          },
+        });
+      }
+    }
+    
+    // Try to serve static file directly
+    const filePath = pathname === "/" ? "index.html" : pathname.slice(1);
+    const file = Bun.file(filePath);
+    
+    if (await file.exists()) {
+      return new Response(file);
+    }
+    
+    // SPA fallback - serve index.html
+    const indexFile = Bun.file("index.html");
+    if (await indexFile.exists()) {
+      return new Response(indexFile, {
+        headers: { "content-type": "text/html" },
+      });
+    }
+    
+    return new Response("Not Found", { status: 404 });
+  },
+});
+
+console.log(\`🚀 Bun server running at http://\${hostname}:\${port}\`);
+`;
+
+  await fs.writeFile(path.join(outDir, 'server.js'), serverContent);
+}
+
+/** Generate Bun config files */
+async function generateBunConfig(_config: AdapterConfig, outDir: string): Promise<void> {
+  // bunfig.toml
+  const bunfigToml = `
+[install]
+# Use exact versions
+exact = true
+
+[run]
+# Auto-install dependencies
+auto-install = true
+
+[deploy]
+# Deployment configuration
+main = "${path.join(outDir, 'server.js')}"
+`;
+
+  await fs.writeFile('bunfig.toml', bunfigToml.trim());
+
+  // package.json for Bun
+  const pkg = {
+    name: 'zylaris-bun-app',
+    version: '1.0.0',
+    type: 'module',
+    scripts: {
+      start: `bun ${path.join(outDir, 'server.js')}`,
+      build: 'zylaris build --adapter bun',
+    },
+    dependencies: {
+      // Bun has built-in server support
+    },
+  };
+
+  await fs.writeFile(path.join(outDir, 'package.json'), JSON.stringify(pkg, 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 bunAdapter;

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

@@ -0,0 +1,278 @@
+/**
+ * Cloudflare Adapter (Pages + Workers)
+ * Supports: Cloudflare Pages (Static + Functions) & Cloudflare Workers
+ */
+
+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 cloudflareAdapter: Adapter = {
+  name: 'cloudflare',
+  target: 'cloudflare',
+
+  async build(config: AdapterConfig): Promise<BuildResult> {
+    const outDir = path.resolve(config.outDir || 'dist');
+    const isWorkers = config.function?.name !== undefined;
+    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);
+
+      // Copy public assets
+      await copyPublic(outDir);
+
+      // Build worker/function
+      if (isWorkers) {
+        await buildWorker(config, outDir);
+      } else {
+        await buildPagesFunction(config, outDir);
+      }
+
+      // Generate config files
+      await generateCloudflareConfig(config, outDir, isWorkers);
+
+      // 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 = 8788): Promise<void> {
+    const { execSync } = await import('child_process');
+    
+    console.log('Starting Cloudflare Pages dev server...');
+    execSync(`npx wrangler pages dev ${config.outDir || 'dist'} --port ${port}`, { stdio: 'inherit' });
+  },
+
+  async deploy(config: AdapterConfig): Promise<void> {
+    const { execSync } = await import('child_process');
+    
+    if (config.function?.name) {
+      console.log('Deploying to Cloudflare Workers...');
+      execSync('npx wrangler deploy', { stdio: 'inherit' });
+    } else {
+      console.log('Deploying to Cloudflare Pages...');
+      execSync('npx wrangler pages deploy dist', { stdio: 'inherit' });
+    }
+  }
+};
+
+/** Build Cloudflare Worker */
+async function buildWorker(config: AdapterConfig, outDir: string): Promise<void> {
+  const entryContent = `
+import { handleRequest } from '@zylaris/server/edge';
+
+export interface Env {
+  // Environment bindings
+}
+
+export default {
+  async fetch(request: Request, env: Env, ctx: ExecutionContext): Promise<Response> {
+    return handleRequest(request, {
+      env,
+      ctx,
+    });
+  },
+};
+`;
+
+  // Build worker
+  const { build } = await import('esbuild');
+  await build({
+    stdin: {
+      contents: entryContent,
+      resolveDir: process.cwd(),
+    },
+    bundle: true,
+    format: 'esm',
+    platform: 'neutral',
+    target: 'es2022',
+    outfile: path.join(outDir, 'worker.js'),
+    external: ['cloudflare:*'],
+    minify: true,
+  });
+
+  // Generate wrangler.toml
+  const wranglerConfig = `
+name = "${config.function?.name || 'zylaris-app'}"
+main = "worker.js"
+compatibility_date = "2024-01-01"
+
+[build]
+command = ""
+
+[[routes]]
+pattern = "${config.function?.route || '*/*'}"
+custom_domain = false
+`;
+
+  await fs.writeFile('wrangler.toml', wranglerConfig.trim());
+}
+
+/** Build Cloudflare Pages Function */
+async function buildPagesFunction(_config: AdapterConfig, outDir: string): Promise<void> {
+  const functionsDir = path.join(outDir, 'functions');
+  await fs.mkdir(functionsDir, { recursive: true });
+
+  const entryContent = `
+import { handleRequest } from '@zylaris/server/edge';
+
+export async function onRequest(context) {
+  const { request, env, params } = context;
+  
+  return handleRequest(request, {
+    env,
+    params,
+  });
+}
+`;
+
+  // Build 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(functionsDir, '[[path]].js'),
+    external: ['cloudflare:*'],
+    minify: true,
+  });
+}
+
+/** Generate Cloudflare config files */
+async function generateCloudflareConfig(
+  config: AdapterConfig, 
+  outDir: string,
+  isWorkers: boolean
+): Promise<void> {
+  // _headers
+  const headers = [
+    '/*',
+    '  X-Frame-Options: DENY',
+    '  X-Content-Type-Options: nosniff',
+    '  Referrer-Policy: strict-origin-when-cross-origin',
+    '',
+    '/_assets/*',
+    '  Cache-Control: public, max-age=31536000, immutable',
+    ...Object.entries(config.headers || {}).map(([path, header]) => 
+      `\n${path}\n  ${header}`
+    ),
+  ].join('\n');
+
+  await fs.writeFile(path.join(outDir, '_headers'), headers);
+
+  // _redirects
+  const redirects = [
+    ...(config.redirects || []).map(r => 
+      `${r.from} ${r.to} ${r.status || 301}`
+    ),
+  ].join('\n');
+
+  if (redirects) {
+    await fs.writeFile(path.join(outDir, '_redirects'), redirects);
+  }
+
+  // _routes.json for Pages
+  if (!isWorkers) {
+    const routesJson = {
+      version: 1,
+      include: ['/*'],
+      exclude: [
+        '/_assets/*',
+        '/*.ico',
+        '/*.png',
+        '/*.jpg',
+        '/*.svg',
+        '/*.css',
+        '/*.js',
+      ],
+    };
+    await fs.writeFile(path.join(outDir, '_routes.json'), JSON.stringify(routesJson, null, 2));
+  }
+
+  // wrangler.toml for Workers
+  if (isWorkers) {
+    const wranglerToml = `
+name = "${config.function?.name || 'zylaris-app'}"
+compatibility_date = "2024-01-01"
+
+[build]
+command = ""
+`;
+    await fs.writeFile('wrangler.toml', wranglerToml.trim());
+  }
+}
+
+/** 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 cloudflareAdapter;

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

@@ -0,0 +1,219 @@
+/**
+ * Deno Deploy Adapter
+ * For: Deno Deploy edge runtime
+ */
+
+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 denoAdapter: Adapter = {
+  name: 'deno',
+  target: 'deno',
+
+  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);
+
+      // Copy public assets
+      await copyPublic(outDir);
+
+      // Build Deno server entry
+      await buildDenoEntry(config, outDir);
+
+      // Generate config files
+      await generateDenoConfig(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] = `/${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 = 8000): Promise<void> {
+    const { execSync } = await import('child_process');
+    const outDir = path.resolve(config.outDir || 'dist');
+    
+    console.log('Starting Deno server...');
+    execSync(`deno run --allow-net --allow-read --allow-env ${path.join(outDir, 'server.ts')}`, { 
+      stdio: 'inherit',
+      env: { ...process.env, PORT: String(port) }
+    });
+  },
+
+  async deploy(config: AdapterConfig): Promise<void> {
+    const { execSync } = await import('child_process');
+    const outDir = path.resolve(config.outDir || 'dist');
+    
+    console.log('Deploying to Deno Deploy...');
+    execSync(`deno deploy --project=${config.function?.name || 'zylaris-app'} ${path.join(outDir, 'server.ts')}`, { 
+      stdio: 'inherit' 
+    });
+  }
+};
+
+/** Build Deno server entry */
+async function buildDenoEntry(_config: AdapterConfig, outDir: string): Promise<void> {
+  const serverContent = `
+// @deno-types="https://deno.land/std/http/server.ts"
+import { serve } from "https://deno.land/std@0.200.0/http/server.ts";
+
+const port = parseInt(Deno.env.get("PORT") || "8000");
+
+// Serve static files
+async function serveStatic(request: Request): Promise<Response> {
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  
+  // Static assets
+  if (pathname.startsWith("/_assets/")) {
+    try {
+      const filePath = pathname.slice(1);
+      const file = await Deno.readFile(filePath);
+      const ext = filePath.split('.').pop();
+      const contentType = getContentType(ext);
+      
+      return new Response(file, {
+        headers: {
+          "content-type": contentType,
+          "cache-control": "public, max-age=31536000, immutable",
+        },
+      });
+    } catch {
+      return new Response("Not Found", { status: 404 });
+    }
+  }
+  
+  // Serve index.html for all routes (SPA)
+  try {
+    const html = await Deno.readTextFile("./index.html");
+    return new Response(html, {
+      headers: { "content-type": "text/html" },
+    });
+  } catch {
+    return new Response("Not Found", { status: 404 });
+  }
+}
+
+function getContentType(ext: string | undefined): string {
+  const types: Record<string, string> = {
+    js: "application/javascript",
+    css: "text/css",
+    html: "text/html",
+    json: "application/json",
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    gif: "image/gif",
+    svg: "image/svg+xml",
+    ico: "image/x-icon",
+  };
+  return types[ext || ""] || "application/octet-stream";
+}
+
+console.log(\`🚀 Deno server running at http://localhost:\${port}\`);
+
+await serve(serveStatic, { port });
+`;
+
+  await fs.writeFile(path.join(outDir, 'server.ts'), serverContent);
+}
+
+/** Generate Deno config files */
+async function generateDenoConfig(config: AdapterConfig, outDir: string): Promise<void> {
+  // deno.json
+  const denoJson = {
+    tasks: {
+      start: `deno run --allow-net --allow-read --allow-env ${path.join(outDir, 'server.ts')}`,
+      deploy: `deno deploy --project=${config.function?.name || 'zylaris-app'} ${path.join(outDir, 'server.ts')}`,
+    },
+    deploy: {
+      project: config.function?.name || 'zylaris-app',
+      include: ['dist/**/*'],
+      exclude: [],
+    },
+  };
+
+  await fs.writeFile('deno.json', JSON.stringify(denoJson, null, 2));
+
+  // Generate import map for Deno Deploy
+  const importMap = {
+    imports: {
+      "@zylaris/core": "https://esm.sh/@zylaris/core",
+      "@zylaris/server": "https://esm.sh/@zylaris/server",
+    },
+  };
+
+  await fs.writeFile('import_map.json', JSON.stringify(importMap, 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 denoAdapter;