@astrale-os/adapter-cloudflare 0.5.0-beta.2 → 0.5.0-beta.21

package/src/params.ts

@@ -1,92 +0,0 @@
-/**
- * `CloudflareParams` — the provider-typed config for the Cloudflare adapter.
- *
- * One type covers every env; per-env differences are just optional fields. The
- * same `{ dev, prod, canary, … }` map a developer writes in `astrale.config.ts`
- * is `Record<string, CloudflareParams>`.
- *
- * Three deployment shapes fall out of which fields are set:
- *   • dev (local)      — `watch()` runs `wrangler dev`; URL = http://localhost:<port>
- *   • dev-remote       — `deploy()` with no `route`; URL = https://<name>.<sub>.workers.dev
- *   • remote (custom)  — `deploy()` with `route`; URL = https://<route>
- */
-export interface CloudflareParams {
-  /**
-   * Custom route / hostname for a routed deploy, e.g. `'crm.acme.dev'`. Omit to
-   * deploy to `*.workers.dev`. Ignored by local `wrangler dev` (URL is
-   * localhost) but still used as the placeholder base domain there.
-   */
-  readonly route?: string
-  /** Gitignored secrets file (whole contents = secrets), e.g. `'.env.dev'`. */
-  readonly secrets?: string
-  /** Local dev port for `wrangler dev`. Default 8787. */
-  readonly port?: number
-  /**
-   * Public URL the dev server is reached through (tunnel / sandbox preview /
-   * reverse proxy), e.g. `'https://my-box.preview.dev'`. Sets BOTH effects an
-   * off-localhost dev needs: wrangler binds 0.0.0.0 (reachable from outside)
-   * and `WORKER_URL` is pinned to this URL so the worker's per-request-Host
-   * identity (`iss`) doesn't drift to the proxy's internal hostname.
-   * Usually injected by `pnpm dev --host <url>` rather than written here.
-   */
-  readonly host?: string
-  /** Override the Worker name. Default: derived from the domain origin. */
-  readonly workerName?: string
-  /** Run `wrangler dev --remote` (edge isolate) instead of local workerd. */
-  readonly remote?: boolean
-  /** Extra plain (non-secret) vars to inject as Worker vars. */
-  readonly vars?: Record<string, string>
-  /**
-   * Escape hatch: raw wrangler config deep-merged over the generated base. Use
-   * it to declare extra bindings the adapter has no typed field for — KV, R2,
-   * D1, queues, service bindings, extra `compatibility_flags`, cron `triggers`,
-   * Hyperdrive, etc.
-   *
-   *   wrangler: {
-   *     kv_namespaces: [{ binding: 'CACHE', id: '<kv-id>' }],
-   *     r2_buckets: [{ binding: 'FILES', bucket_name: 'my-bucket' }],
-   *   }
-   *
-   * The merge is additive: arrays concat (so your `services` keep the adapter's
-   * `SELF` binding and your `compatibility_flags` keep `nodejs_compat`); new
-   * keys are added as-is. The adapter-owned keys `name`, `main`, `assets`,
-   * `routes` are rejected — use `workerName` and `route` instead. Avoid
-   * the reserved binding names `SELF` and `ASSETS`. Durable Objects need extra
-   * worker-entry codegen and aren't supported through this field yet.
-   */
-  readonly wrangler?: Record<string, unknown>
-  /**
-   * Route subrequests to platform INSTANCE hostnames through a service binding
-   * instead of the public edge. A Cloudflare Worker can't fetch a same-zone
-   * hostname served by another Worker — Cloudflare 522s it — so without this the
-   * worker can't fetch an instance kernel's JWKS to verify an inbound credential
-   * from that instance, and every cross-instance call (install hooks, the GUI's
-   * delegated calls, authed views) fails with `2002 Credential verification
-   * failed`. Point it at a router Worker that reaches those hosts internally
-   * (Astrale: `admin-router`).
-   *
-   * Wires BOTH halves the SDK needs: the `<binding>` service binding in the
-   * generated wrangler config, and a `routeSubrequest` predicate in the worker
-   * entry that diverts matching hosts through it.
-   *
-   * ON BY DEFAULT (targets `admin-router`) so every adapter-deployed worker can
-   * verify cross-instance credentials out of the box. Pass `false` to disable
-   * (a domain that never talks to another instance, or an account without a
-   * router), or an object to override the target / binding name / host match.
-   *
-   *   router: false                      // opt out
-   *   router: { service: 'my-router' }   // override target
-   */
-  readonly router?:
-    | false
-    | {
-        /** Router Worker the binding targets. Default `'admin-router'`. */
-        readonly service?: string
-        /** Service-binding name the worker reads. Default `'ROUTER'`. */
-        readonly binding?: string
-        /** Host suffix that marks an instance host. Default `'.astrale.ai'`. */
-        readonly hostSuffix?: string
-        /** Min dot-separated label count for an instance host. Default `4` (`<slug>.<region>.astrale.ai`). */
-        readonly minLabels?: number
-      }
-}

package/src/worker/index.ts

@@ -1,276 +0,0 @@
-import type { schema } from '@astrale-os/kernel-dsl/v1'
-import type { DomainDefinition, FrontendRoute } from '@astrale-os/sdk'
-import type {
-  Application,
-  RemoteDeploymentInput,
-  RemoteIdentityInput,
-} from '@astrale-os/sdk/server'
-import type { ExecutionContext, Hono } from 'hono'
-
-import { issuer } from '@astrale-os/kernel-core/auth'
-import { createRemoteApplication } from '@astrale-os/sdk/server'
-import { Hono as HonoApplication } from 'hono'
-
-const MAXIMUM_CACHED_APPLICATIONS = 4
-const APPLICATION_CLOSE_TIMEOUT_MS = 5_000
-
-/** SDK-owned Publication manifest passed through without adapter interpretation. */
-export type CloudflareManifest = NonNullable<RemoteDeploymentInput['manifest']>
-
-export interface Fetcher {
-  fetch(request: Request): Response | Promise<Response>
-}
-
-/** Adapter-owned bindings generated into every Cloudflare deployment. */
-export interface CloudflareAdapterBindings {
-  /** Native Cloudflare deployment metadata (direct Wrangler deployments). */
-  readonly ASTRALE_VERSION_METADATA?: {
-    readonly id: string
-    readonly tag: string
-    readonly timestamp: string
-  }
-  /** Content-derived generation supplied by providers without version metadata. */
-  readonly ASTRALE_DEPLOYMENT_VERSION?: string
-  readonly WORKER_URL?: string
-  readonly ASSETS?: Fetcher
-  readonly SELF?: Fetcher
-  readonly FRONTEND_DEV_URL?: string
-  readonly DISPATCHER?: { get(name: string): Fetcher }
-}
-
-export interface CloudflareWorkerConfig<
-  S extends schema.DomainSchema,
-  Bindings extends CloudflareAdapterBindings,
-  Environment,
-> {
-  readonly definition: DomainDefinition<S>
-  readonly privateKey:
-    | RemoteIdentityInput['privateKey']
-    | ((bindings: Bindings) => RemoteIdentityInput['privateKey'])
-  /** Compose provider bindings into the exact Domain environment once per deployment generation. */
-  readonly resolveEnvironment?: (bindings: Bindings) => Environment | Promise<Environment>
-  readonly manifest?: CloudflareManifest
-  readonly resolveUrl?: (bindings: Bindings, requestOrigin: string) => string
-  readonly selfBinding?: (bindings: Bindings) => Fetcher | null | undefined
-  readonly routeSubrequest?: (url: URL, bindings: Bindings) => Fetcher | null | undefined
-}
-
-export interface CloudflareWorker<Environment> {
-  fetch(
-    request: Request,
-    environment: Environment,
-    executionContext?: ExecutionContext,
-  ): Response | Promise<Response>
-}
-
-interface CachedApplication<Environment> {
-  readonly origin: string
-  readonly application: Application<Hono>
-  readonly environment: Environment
-}
-
-/**
- * Compose one Cloudflare module Worker without request-global mutation.
- * Environment bindings are captured once per immutable serving URL/version generation.
- */
-export function cloudflareWorkerEntry<
-  Bindings extends CloudflareAdapterBindings,
-  Environment = Bindings,
->() {
-  return function <const S extends schema.DomainSchema>(
-    config: CloudflareWorkerConfig<S, Bindings, Environment>,
-  ): CloudflareWorker<Bindings> {
-    const applications = new Map<string, CachedApplication<Environment>>()
-
-    const applicationFor = async (
-      url: string,
-      bindings: Bindings,
-    ): Promise<CachedApplication<Environment>> => {
-      const version = deploymentVersion(bindings)
-      const key = `${url}\u0000${version}`
-      const cached = applications.get(key)
-      if (cached !== undefined) return cached
-      const environment =
-        config.resolveEnvironment === undefined
-          ? (bindings as unknown as Environment)
-          : await config.resolveEnvironment(bindings)
-
-      const routedFetch: typeof fetch = async (input, init) => {
-        const request = new Request(input, init)
-        const destination = new URL(request.url)
-        if (destination.origin === new URL(url).origin) {
-          const self = config.selfBinding?.(bindings)
-          if (self !== null && self !== undefined) return self.fetch(request)
-          return serving.app.fetch(request, environment)
-        }
-        const route = config.routeSubrequest?.(destination, bindings)
-        return route === null || route === undefined ? fetch(request) : route.fetch(request)
-      }
-
-      const deploymentQuery = `deployment=${encodeURIComponent(version)}`
-      const issuerId = issuer.accept(url)
-      const host = new HonoApplication()
-      host.get('/meta', (context) =>
-        context.json({
-          origin: config.definition.schema.origin,
-          issuer: issuerId,
-          schemaRevision: config.definition.domain.$.revision,
-          deploymentVersion: version,
-        }),
-      )
-      const serving: Application<Hono> = createRemoteApplication({
-        definition: config.definition,
-        environment,
-        identity: {
-          issuer: issuerId,
-          subject: config.definition.schema.origin,
-          privateKey:
-            typeof config.privateKey === 'function'
-              ? config.privateKey(bindings)
-              : config.privateKey,
-          fetch: routedFetch,
-          ...(new URL(url).protocol === 'http:' ? { allowInsecureHttp: true } : {}),
-        },
-        deployment: {
-          bundleHref: `${url}/.well-known/astrale/domain.bundle.json?${deploymentQuery}`,
-          endpoint: { http: `${url}/invoke` },
-          ...(config.definition.frontend === undefined
-            ? {}
-            : { frontendBaseHref: url, frontendCacheKey: version }),
-          ...(config.manifest === undefined ? {} : { manifest: config.manifest }),
-          installation: {
-            href: `${url}/install`,
-            method: 'POST',
-            authentication: { kind: 'public' },
-          },
-        },
-        app: host,
-        server: {
-          path: '/invoke',
-          health: { probe: { check: () => true } },
-          limits: {
-            maximumRequestBytes: 1024 * 1024,
-            maximumPublicationBytes: 1024 * 1024,
-            maximumBundleBytes: 8 * 1024 * 1024,
-            maximumInstallationBytes: 8 * 1024 * 1024,
-            invocationTimeoutMs: 30_000,
-          },
-        },
-      })
-      const created = Object.freeze({
-        origin: new URL(url).origin,
-        application: serving,
-        environment,
-      })
-      if (applications.size >= MAXIMUM_CACHED_APPLICATIONS) {
-        const oldest = applications.keys().next().value
-        if (oldest !== undefined) {
-          const evicted = applications.get(oldest)
-          applications.delete(oldest)
-          if (evicted !== undefined) {
-            try {
-              await closeEvictedApplication(evicted.application)
-            } catch (cause) {
-              await serving
-                .close({ deadline: Date.now() + APPLICATION_CLOSE_TIMEOUT_MS })
-                .catch(() => undefined)
-              throw cause
-            }
-          }
-        }
-      }
-      applications.set(key, created)
-      return created
-    }
-
-    return Object.freeze({
-      async fetch(request: Request, bindings: Bindings, executionContext?: ExecutionContext) {
-        const requestUrl = new URL(request.url)
-        if (config.definition.frontend !== undefined) {
-          const asset = await frontendAsset(config.definition, bindings, requestUrl, request)
-          if (asset !== undefined) return asset
-        }
-        const publicUrl = canonicalServingUrl(
-          config.resolveUrl?.(bindings, requestOrigin(requestUrl, request)) ??
-            bindings.WORKER_URL ??
-            requestOrigin(requestUrl, request),
-        )
-        const serving = await applicationFor(publicUrl, bindings)
-        return serving.application.app.fetch(request, serving.environment, executionContext)
-      },
-    })
-  }
-}
-
-/** Close an evicted Application before its environment bindings leave the cache. */
-export function closeEvictedApplication(
-  application: Pick<Application, 'close'>,
-  now: () => number = Date.now,
-): Promise<void> {
-  return application.close({ deadline: now() + APPLICATION_CLOSE_TIMEOUT_MS })
-}
-
-async function frontendAsset<S extends schema.DomainSchema>(
-  definition: DomainDefinition<S>,
-  environment: CloudflareAdapterBindings,
-  url: URL,
-  request: Request,
-): Promise<Response | undefined> {
-  const frontend = definition.frontend
-  if (frontend === undefined || frontend.source.kind === 'external') return undefined
-  const routes = frontend.routes as Readonly<Record<string, FrontendRoute>>
-  const route = Object.values(routes).find((candidate) => candidate.path === url.pathname)
-  const staticAsset = url.pathname.startsWith('/assets/')
-  if (route === undefined && !staticAsset) return undefined
-  if (request.method !== 'GET' && request.method !== 'HEAD') return undefined
-  const binding = environment.ASSETS
-  if (binding === undefined) return undefined
-  const dev = environment.FRONTEND_DEV_URL?.replace(/\/+$/u, '')
-  if (dev !== undefined && dev.length > 0) {
-    return fetch(new Request(`${dev}${url.pathname}${url.search}`, request))
-  }
-  const path =
-    route === undefined ? `${url.pathname}${url.search}` : `/${route.document}${url.search}`
-  return binding.fetch(new Request(new URL(path, url.origin), request))
-}
-
-function requestOrigin(url: URL, request: Request): string {
-  if (url.protocol !== 'http:') return url.origin
-  const forwarded = request.headers.get('x-forwarded-proto')?.split(',')[0]?.trim().toLowerCase()
-  return forwarded === 'https' ? `https://${url.host}` : url.origin
-}
-
-function canonicalServingUrl(input: string): string {
-  let url: URL
-  try {
-    url = new URL(input)
-  } catch (cause) {
-    throw new TypeError('Cloudflare Worker serving URL is invalid.', { cause })
-  }
-  if (
-    (url.protocol !== 'https:' && url.protocol !== 'http:') ||
-    url.username !== '' ||
-    url.password !== '' ||
-    url.pathname !== '/' ||
-    url.search !== '' ||
-    url.hash !== ''
-  ) {
-    throw new TypeError('Cloudflare Worker serving URL must be one HTTP(S) origin.')
-  }
-  return url.origin
-}
-
-function deploymentVersion(environment: CloudflareAdapterBindings): string {
-  const input = environment.ASTRALE_VERSION_METADATA
-  if (
-    input !== null &&
-    typeof input === 'object' &&
-    typeof input.id === 'string' &&
-    input.id.length > 0
-  ) {
-    return input.id
-  }
-  const fallback = environment.ASTRALE_DEPLOYMENT_VERSION
-  if (typeof fallback === 'string' && fallback.length > 0) return fallback
-  throw new TypeError('Cloudflare Worker deployment version is unavailable.')
-}

package/src/worker/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "compilerOptions": {
-    "noEmit": true,
-    "types": [],
-    "lib": ["ES2023", "DOM", "DOM.Iterable"],
-    "skipLibCheck": true
-  },
-  "include": ["index.ts"]
-}