Wie man vorab signierte URLs für Firebase Storage mit Astro auf Cloudflare Workers generiert

name = "firebase-storage-astro-workers"
main = "dist/_worker.js"
compatibility_date = "2025-04-01"
compatibility_flags = [ "nodejs_compat" ]

[assets]
directory="dist"
binding="ASSETS"

[vars]
FIREBASE_CLIENT_ID=""
FIREBASE_PROJECT_ID=""
FIREBASE_PRIVATE_KEY=""
FIREBASE_CLIENT_EMAIL=""
FIREBASE_STORAGE_BUCKET=""
FIREBASE_PRIVATE_KEY_ID=""
FIREBASE_CLIENT_X509_CERT_URL=""

// ... Bestehende Importe ...
import { defineConfig, envField } from 'astro/config'

export default defineConfig({
  env: {
    schema: {
      FIREBASE_PROJECT_ID: envField.string({ context: 'server', access: 'secret', optional: false }),
      FIREBASE_CLIENT_X509_CERT_URL: envField.string({ context: 'server', access: 'secret', optional: false }),
      FIREBASE_PRIVATE_KEY_ID: envField.string({ context: 'server', access: 'secret', optional: false }),
      FIREBASE_PRIVATE_KEY: envField.string({ context: 'server', access: 'secret', optional: false }),
      FIREBASE_CLIENT_ID: envField.string({ context: 'server', access: 'secret', optional: false }),
      FIREBASE_CLIENT_EMAIL: envField.string({ context: 'server', access: 'secret', optional: false }),
      FIREBASE_STORAGE_BUCKET: envField.string({ context: 'server', access: 'secret', optional: false }),
    }
  }
  // adapter
})

import { getSecret } from 'astro:env/server'

const project_id = getSecret('FIREBASE_PROJECT_ID')
const private_key_id = getSecret('FIREBASE_PRIVATE_KEY_ID')
const private_key = getSecret('FIREBASE_PRIVATE_KEY')
const client_email = getSecret('FIREBASE_CLIENT_EMAIL')
const client_id = getSecret('FIREBASE_CLIENT_ID')
const storageBucket = getSecret('FIREBASE_STORAGE_BUCKET')
const client_x509_cert_url = getSecret('FIREBASE_CLIENT_X509_CERT_URL')

export default function getFirebaseConfig() {
  return {
    type: 'service_account',
    client_id,
    project_id,
    private_key,
    client_email,
    storageBucket,
    private_key_id,
    client_x509_cert_url,
    universe_domain: 'googleapis.com',
    token_uri: 'https://oauth2.googleapis.com/token',
    auth_uri: 'https://accounts.google.com/o/oauth2/auth',
    auth_provider_x509_cert_url: 'https://www.googleapis.com/oauth2/v1/certs',
  }
}

import getFirebaseConfig from './config'
import { importPKCS8, SignJWT } from 'jose'

const serviceAccount = getFirebaseConfig()

async function getAccessTokenWithJose() {
  const privateKeyPem = serviceAccount.private_key
  const clientEmail = serviceAccount.client_email
  if (!privateKeyPem) throw new Error(`FIREBASE_PRIVATE_KEY environment variable is not available`)
  const iat = Math.floor(Date.now() / 1000)
  const exp = iat + 3600
  const jwt = await new SignJWT({
    iss: clientEmail,
    scope: 'https://www.googleapis.com/auth/devstorage.full_control',
    aud: 'https://oauth2.googleapis.com/token',
    iat,
    exp,
  })
    .setProtectedHeader({ alg: 'RS256' })
    .sign(await importPKCS8(privateKeyPem, 'RS256'))
  const res = await fetch('https://oauth2.googleapis.com/token', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/x-www-form-urlencoded',
    },
    body: new URLSearchParams({
      assertion: jwt,
      grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
    }),
  })
  const data = await res.json()
  if (!res.ok) throw new Error(`Token error: ${data.error}`)
  return data.access_token
}

// ...Bestehende Importe...

// ...Bestehender Code...

async function setBucketCORS(bucketName) {
  const accessToken = await getAccessTokenWithJose()
  const corsConfig = {
    cors: [
      {
        origin: [
          'http://localhost:3000',
          'https://your-deployment.workers.dev',
        ],
        maxAgeSeconds: 3600,
        method: ['GET', 'PUT', 'POST'],
        responseHeader: ['Content-Type', 'Content-MD5', 'Content-Disposition'],
      },
    ],
  }
  const res = await fetch(`https://storage.googleapis.com/storage/v1/b/${bucketName.replace('gs://', '')}`, {
    method: 'PATCH',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${accessToken}`,
    },
    body: JSON.stringify(corsConfig),
  })
  if (!res.ok) {
    const err = await res.text()
    console.warn(`Failed to update CORS: ${res.statusText}\n${err}`)
  }
}

// ...Bestehende Importe...
import { createHash, createSign } from 'node:crypto'

async function generateSignedUrl(bucketName, objectName, { subresource = null, expiration = 604800, httpMethod = 'GET', queryParameters = {}, headers = {} } = {}) {
  if (expiration > 604800) throw new Error("Expiration can't be longer than 7 days (604800 seconds).")
  const privateKey = serviceAccount.private_key
  if (!privateKey) throw new Error(`FIREBASE_PRIVATE_KEY environment variable is not available`)
  const clientEmail = serviceAccount.client_email
  const now = new Date()
  const datestamp = now.toISOString().slice(0, 10).replace(/-/g, '')
  const timestamp = `${datestamp}T${now.toISOString().slice(11, 19).replace(/:/g, '')}Z`
  const credentialScope = `${datestamp}/auto/storage/goog4_request`
  const credential = `${clientEmail}/${credentialScope}`
  const host = `${bucketName.replace('gs://', '')}.storage.googleapis.com`
  headers['host'] = host
  // Kanonische Header
  const sortedHeaders = Object.keys(headers)
    .sort()
    .reduce((obj, key) => {
      obj[key.toLowerCase()] = headers[key].toLowerCase()
      return obj
    }, {})
  const canonicalHeaders = Object.entries(sortedHeaders)
    .map(([k, v]) => `${k}:${v}\n`)
    .join('')
  const signedHeaders = Object.keys(sortedHeaders).join(';')
  // Kanonische Abfragezeichenfolge
  const fullQueryParams: Record<string, any> = {
    ...queryParameters,
    'X-Goog-Date': timestamp,
    'X-Goog-Credential': credential,
    'X-Goog-SignedHeaders': signedHeaders,
    'X-Goog-Algorithm': 'GOOG4-RSA-SHA256',
    'X-Goog-Expires': expiration.toString(),
  }
  if (subresource) fullQueryParams[subresource] = ''
  const orderedQueryParams = Object.keys(fullQueryParams)
    .sort()
    .map((key) => `${encodeURIComponent(key)}=${encodeURIComponent(fullQueryParams[key])}`)
    .join('&')
  const canonicalUri = `/${encodeURIComponent(objectName).replace(/%2F/g, '/')}`
  const canonicalRequest = [httpMethod, canonicalUri, orderedQueryParams, canonicalHeaders, signedHeaders, 'UNSIGNED-PAYLOAD'].join('\n')
  const hash = createHash('sha256').update(canonicalRequest).digest('hex')
  const stringToSign = ['GOOG4-RSA-SHA256', timestamp, credentialScope, hash].join('\n')
  const signature = createSign('RSA-SHA256').update(stringToSign).sign(privateKey).toString('hex')
  return `https://${host}${canonicalUri}?${orderedQueryParams}&X-Goog-Signature=${signature}`
}

// ...Bestehender Code...

// ...Bestehender Code...

export async function getFirebaseObject(Key: string) {
  try {
    await setBucketCORS(serviceAccount.storageBucket)
    return await generateSignedUrl(serviceAccount.storageBucket, Key, {
      httpMethod: 'GET',
      expiration: 60 * 60 * 24,
    })
  } catch (e: any) {
    const tmp = e.message || e.toString()
    console.log(tmp)
    return
  }
}

// ...Bestehender Code...

export async function uploadFirebaseObject(file: { name: string; type: string }) {
  try {
    await setBucketCORS(serviceAccount.storageBucket)
    return await generateSignedUrl(serviceAccount.storageBucket, file.name, {
      httpMethod: 'PUT',
      expiration: 60 * 60 * 24,
      headers: {
        'Content-Type': file.type,
      },
    })
  } catch (e: any) {
    const tmp = e.message || e.toString()
    console.log(tmp)
    return
  }
}

import type { APIContext } from 'astro'
import { getFirebaseObject, uploadFirebaseObject } from '../../storage/firebase/index'

// Definieren Sie eine asynchrone Funktion namens GET, die ein Request-Objekt akzeptiert.
export async function GET({ request }: APIContext) {
  // Extrahieren Sie den 'file'-Parameter aus der Anforderungs-URL.
  const url = new URL(request.url)
  const file = url.searchParams.get('file')
  // Überprüfen Sie, ob der 'file'-Parameter in der URL vorhanden ist.
  if (file) {
    try {
      const filePublicURL = await getFirebaseObject(file)
      // Geben Sie eine Antwort mit der öffentlichen URL des Bildes und einem 200-Statuscode zurück.
      return new Response(filePublicURL)
    } catch (error: any) {
      // Wenn ein Fehler auftritt, protokollieren Sie die Fehlermeldung und geben Sie eine Antwort mit einem 500-Statuscode zurück.
      const message = error.message || error.toString()
      console.log(message)
      return new Response(message, { status: 500 })
    }
  }
  // Wenn der 'file'-Parameter nicht in der URL gefunden wird, geben Sie eine Antwort mit einem 400-Statuscode zurück.
  return new Response('Invalid Request.', { status: 400 })
}

export async function POST({ request }: APIContext) {
    // Extrahieren Sie den 'file'-Parameter aus der Anforderungs-URL.
    const url = new URL(request.url)
    const type = url.searchParams.get('type')
    const name = url.searchParams.get('name')
    if (!type || !name) return new Response('Invalid Request.', {status:400})
    try {
      // Generieren Sie eine zugängliche URL für die hochgeladene Datei
      // Verwenden Sie diese URL, um einen GET an diesen Endpunkt mit dem file-Abfrageparameter zu senden, der wie unten angegeben ist
      const publicUploadUrl = await uploadFirebaseObject({ type, name })
      // Geben Sie eine Erfolgsmeldung mit einer Nachricht zurück
      return new Response(publicUploadUrl)
    } catch (error: any) {
      // Wenn während des Hochladevorgangs ein Fehler auftritt, geben Sie eine 403-Antwort mit der Fehlermeldung zurück
      const message = error.message || error.toString()
      console.log(message)
      return new Response(message, { status: 500 })
    }
}