@photonjs/cloudflare

import { cloudflare } from '@photonjs/cloudflare/vite'

import { asFetch } from '@photonjs/cloudflare/hono'

import { asFetch } from '@photonjs/cloudflare/h3'

function cloudflare(options?: CloudflareOptions): Plugin

// vite.config.ts
import { photon } from '@photonjs/core/vite'
import { cloudflare } from '@photonjs/cloudflare/vite'
 
export default {
  plugins: [
    photon({
      server: './src/server.ts'
    }),
    cloudflare()
  ]
}

function asFetch(app: Hono): ExportedHandlerFetchHandler

import { Hono } from 'hono'
import { asFetch } from '@photonjs/cloudflare/hono'
 
const app = new Hono()
app.get('/', (c) => c.text('Hello Cloudflare!'))
 
export default { fetch: asFetch(app) }

function asFetch(app: App): ExportedHandlerFetchHandler

import { createApp, defineEventHandler } from 'h3'
import { asFetch } from '@photonjs/cloudflare/h3'
 
const app = createApp()
app.use('/', defineEventHandler(() => 'Hello Cloudflare!'))
 
export default { fetch: asFetch(app) }

interface CloudflareOptions {
  entry?: string
  wrangler?: WranglerConfig
  pages?: boolean
}

cloudflare({
  entry: './cloudflare-entry.ts'
})

cloudflare({
  wrangler: {
    configPath: './wrangler.toml',
    environment: 'production'
  }
})

cloudflare({
  pages: true
})

// cloudflare-entry.ts
import handler from 'photon:cloudflare-entry'
 
export default handler

// In your handlers
app.get('/api/config', (c) => {
  return c.json({
    environment: c.env.ENVIRONMENT,
    version: c.env.VERSION
  })
})

app.get('/api/data/:key', async (c) => {
  const key = c.req.param('key')
  const value = await c.env.MY_KV.get(key)
  
  if (!value) {
    return c.notFound()
  }
  
  return c.json({ key, value })
})
 
app.put('/api/data/:key', async (c) => {
  const key = c.req.param('key')
  const value = await c.req.text()
  
  await c.env.MY_KV.put(key, value)
  
  return c.json({ success: true })
})

app.get('/api/counter', async (c) => {
  const id = c.env.COUNTER.idFromName('global')
  const stub = c.env.COUNTER.get(id)
  
  const response = await stub.fetch(c.req.raw)
  return response
})

npm install crossws

import { upgradeWebSocket } from 'hono/cloudflare-workers'
 
app.get('/ws', upgradeWebSocket((c) => {
  return {
    onMessage: (event, ws) => {
      ws.send(`Echo: ${event.data}`)
    },
    onClose: () => {
      console.log('Connection closed')
    }
  }
}))

// cloudflare-entry.ts
import { Hono } from 'hono'
import { apply, serve } from '@photonjs/hono'
 
const app = new Hono()
 
// Your application logic
app.get('/', (c) => c.text('Hello!'))
 
// Apply Photon middleware
apply(app)
 
// Custom Cloudflare handler
export default {
  async fetch(request: Request, env: Env, ctx: ExecutionContext) {
    // Custom logic before handling
    console.log(`Request: ${request.method} ${request.url}`)
    
    // Handle with Hono app
    const response = await serve(app).fetch(request, env, ctx)
    
    // Custom logic after handling
    response.headers.set('X-Powered-By', 'Photon + Cloudflare')
    
    return response
  }
}

app.get('/api/cached', async (c) => {
  const cache = caches.default
  const cacheKey = new Request(c.req.url, c.req.raw)
  
  let response = await cache.match(cacheKey)
  
  if (!response) {
    // Generate fresh response
    response = new Response(JSON.stringify({ 
      data: 'fresh',
      timestamp: Date.now()
    }), {
      headers: {
        'Content-Type': 'application/json',
        'Cache-Control': 'public, max-age=300'
      }
    })
    
    // Cache the response
    c.executionCtx.waitUntil(cache.put(cacheKey, response.clone()))
  }
  
  return response
})

app.get('/api/info', (c) => {
  return c.json({
    // Cloudflare request properties
    cf: c.req.raw.cf,
    
    // Environment variables
    environment: c.env.ENVIRONMENT,
    
    // Request headers
    country: c.req.header('cf-ipcountry'),
    ip: c.req.header('cf-connecting-ip')
  })
})

# wrangler.toml
name = "my-photon-app"
main = "dist/cloudflare-entry.js"
compatibility_date = "2024-01-01"
 
[build]
command = "npm run build"
 
[[kv_namespaces]]
binding = "MY_KV"
id = "your-kv-namespace-id"
 
[vars]
ENVIRONMENT = "production"

// functions/_middleware.ts
import handler from '../dist/cloudflare-entry.js'
 
export const onRequest = handler

// In your server setup
app.onError((error, c) => {
  console.error('Cloudflare error:', error)
  
  return c.json({
    error: 'Internal Server Error',
    message: error.message,
    timestamp: new Date().toISOString()
  }, 500)
})

app.get('/api/feature', async (c) => {
  try {
    // Try to use Cloudflare-specific feature
    const result = await c.env.SOME_SERVICE.fetch(request)
    return c.json(result)
  } catch (error) {
    // Fallback for other environments
    console.warn('Cloudflare feature unavailable:', error)
    return c.json({ message: 'Feature unavailable' }, 503)
  }
})

// Optimize for Cloudflare's CPU time limits
app.use('*', async (c, next) => {
  const start = Date.now()
  
  const response = await next()
  
  const duration = Date.now() - start
  if (duration > 50) {
    console.warn(`Slow request: ${duration}ms`)
  }
  
  return response
})

// Optimize memory usage for Cloudflare limits
app.get('/api/large-data', async (c) => {
  // Stream large responses instead of loading into memory
  const stream = new ReadableStream({
    start(controller) {
      // Stream data in chunks
      for (let i = 0; i < 1000; i++) {
        controller.enqueue(`chunk ${i}\n`)
      }
      controller.close()
    }
  })
  
  return new Response(stream, {
    headers: { 'Content-Type': 'text/plain' }
  })
})

// vite.config.ts
import { photon } from '@photonjs/core/vite'
import { cloudflare } from '@photonjs/cloudflare/vite'
 
export default {
  plugins: [
    photon({
      server: './src/server.ts'
    }),
    cloudflare()
  ]
}

// vite.config.ts
export default {
  plugins: [
    photon({
      server: './src/server.ts'
    }),
    cloudflare({
      entry: './src/cloudflare-entry.ts',
      pages: true,
      wrangler: {
        configPath: './wrangler.toml',
        environment: 'production'
      }
    })
  ]
}