supabase-worker-previews 0.0.0 → 0.1.1

package/dist/feedback.js

@@ -0,0 +1,238 @@
+import { branchFor, previewKey } from "./commands/branches.js";
+import { GitHubApi } from "./github.js";
+export const COMMENT_MARKER = "<!-- supabase-worker-previews -->";
+const PAYLOAD_KEY = "swpPullRequest";
+const STATUS = {
+    checking: "Checking",
+    passed: "**Passed**",
+    failed: "**Failed**",
+    removed: "Removed",
+    "cleanup-failed": "**Cleanup failed**",
+};
+const cell = (text) => text.replace(/\|/g, "\\|").replace(/\n/g, " ");
+const code = (text) => `\`${cell(text)}\``;
+function databaseCell(db, dashboardUrl) {
+    if (!db)
+        return "Unknown";
+    const name = `[${code(db.name)}](${dashboardUrl})`;
+    const ref = db.ref ? ` (${code(db.ref)})` : "";
+    return db.kind === "shared" ? `Shared ${name}${ref}` : `Own branch ${name}${ref}`;
+}
+function reason(error) {
+    const text = error.length > 1500 ? `${error.slice(0, 1500)}...` : error;
+    return text.includes("\n") ? `\n\n\`\`\`\n${text}\n\`\`\`` : ` ${text}`;
+}
+export function renderComment(s) {
+    const commit = `[${code(s.sha.slice(0, 7))}](${s.commitUrl})`;
+    const updated = s.updated.toISOString().slice(0, 16).replace("T", " ");
+    const status = s.runUrl ? `${STATUS[s.phase]} ([logs](${s.runUrl}))` : STATUS[s.phase];
+    const lines = [COMMENT_MARKER, `**Supabase Worker Preview** for ${code(s.worker)}`, ""];
+    if (s.phase === "removed") {
+        lines.push(s.database?.kind === "own"
+            ? `The Preview and its own database ${code(s.database.name)} were removed when this PR closed.`
+            : `The Preview was removed when this PR closed. The shared database stays.`, "", `<sub>Last commit ${commit}, ${updated} UTC</sub>`);
+        return lines.join("\n");
+    }
+    const preview = s.previewUrl ? `[Visit Preview](${s.previewUrl})` : "Not deployed yet";
+    lines.push("| Status | Preview | Database | Commit | Updated (UTC) |", "| :-- | :-- | :-- | :-- | :-- |", `| ${status} | ${preview} | ${databaseCell(s.database, s.dashboardUrl)} | ${commit} | ${updated} |`);
+    if (s.error)
+        lines.push("", `**Reason:**${reason(s.error)}`);
+    return lines.join("\n");
+}
+/** `::warning::` lines end at a newline, so GitHub's escapes keep a multi-line message whole. */
+export function warning(message) {
+    return `::warning::${message.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A")}`;
+}
+/**
+ * The PR comment and GitHub deployment for one `swp pr` run. Any GitHub API
+ * failure becomes a warning; only the wrapped database work decides the job.
+ */
+export class Feedback {
+    event;
+    deps;
+    github;
+    commentOn;
+    deploymentsOn;
+    commentId;
+    branch;
+    sha;
+    environment;
+    server;
+    runUrl;
+    constructor(event, deps) {
+        this.event = event;
+        this.deps = deps;
+        const env = deps.env ?? process.env;
+        this.github = deps.github ?? new GitHubApi(deps.githubToken, event.repository.full_name, deps.fetchImpl);
+        this.commentOn = deps.config.prComment !== false && !deps.runner.dryRun;
+        this.deploymentsOn = deps.config.githubDeployments !== false && !deps.runner.dryRun;
+        this.branch = event.pull_request.head.ref;
+        this.sha = event.pull_request.head.sha;
+        this.environment = (deps.config.deploymentEnvironment ?? "Preview").replaceAll("{branch}", this.branch);
+        this.server = env.GITHUB_SERVER_URL ?? "https://github.com";
+        if (env.GITHUB_RUN_ID)
+            this.runUrl = `${this.server}/${event.repository.full_name}/actions/runs/${env.GITHUB_RUN_ID}`;
+    }
+    /** Reports on `work` (up and check) from start to finish, and rethrows its error. */
+    async run(isolated, work) {
+        if (!this.commentOn && !this.deploymentsOn)
+            return work();
+        await this.comment({
+            phase: "checking",
+            previewUrl: await this.previewUrl(),
+            database: await this.database(isolated),
+        });
+        const deployment = await this.startDeployment();
+        try {
+            await work();
+        }
+        catch (err) {
+            const message = err.message;
+            const previewUrl = await this.previewUrl();
+            await this.comment({
+                phase: "failed",
+                previewUrl,
+                database: await this.database(isolated),
+                error: message,
+            });
+            await this.deploymentStatus(deployment, {
+                state: "failure",
+                environmentUrl: previewUrl,
+                description: message,
+            });
+            throw err;
+        }
+        const previewUrl = await this.previewUrl();
+        await this.comment({ phase: "passed", previewUrl, database: await this.database(isolated) });
+        await this.deploymentStatus(deployment, {
+            state: "success",
+            environmentUrl: previewUrl,
+            description: "The Preview serves the expected database",
+        });
+        await this.deactivateDeployments(deployment);
+    }
+    /** Reports on `work` (down) when the PR closes. */
+    /** `isolated`: the PR had its own database, which Supabase's integration may already have deleted. */
+    async close(work, isolated = false) {
+        if (!this.commentOn && !this.deploymentsOn)
+            return work();
+        const own = await branchFor(this.branch, this.deps).catch(() => undefined);
+        const database = own && !own.persistent
+            ? { kind: "own", name: own.name, ref: own.project_ref }
+            : isolated
+                ? { kind: "own", name: this.branch }
+                : undefined;
+        try {
+            await work();
+        }
+        catch (err) {
+            await this.comment({ phase: "cleanup-failed", database, error: err.message });
+            throw err;
+        }
+        await this.comment({ phase: "removed", database });
+        await this.deactivateDeployments();
+    }
+    async database(isolated) {
+        const { config } = this.deps;
+        if (isolated) {
+            const own = await branchFor(this.branch, this.deps).catch(() => undefined);
+            return { kind: "own", name: own?.name ?? this.branch, ref: own?.project_ref };
+        }
+        const shared = await this.deps.supabase
+            .listBranches(config.supabaseProjectRef)
+            .then((all) => all.find((b) => b.name === config.sharedBranch))
+            .catch(() => undefined);
+        return { kind: "shared", name: config.sharedBranch, ref: shared?.project_ref };
+    }
+    async previewUrl() {
+        const preview = await this.deps.cloudflare
+            .findPreview(previewKey(this.branch, this.deps.config, this.event.number))
+            .catch(() => undefined);
+        return preview?.urls[0]?.replace(/\/+$/, "");
+    }
+    async comment(state) {
+        if (!this.commentOn)
+            return;
+        const body = renderComment({
+            ...state,
+            worker: this.deps.config.worker,
+            sha: this.sha,
+            commitUrl: `${this.server}/${this.event.repository.full_name}/pull/${this.event.number}/commits/${this.sha}`,
+            dashboardUrl: `https://supabase.com/dashboard/project/${this.deps.config.supabaseProjectRef}/branches`,
+            updated: (this.deps.clock ?? (() => new Date()))(),
+            runUrl: this.runUrl,
+        });
+        const ok = await this.safe("PR comment", async () => {
+            this.commentId ??= await this.github.findComment(this.event.number, COMMENT_MARKER);
+            if (this.commentId)
+                await this.github.updateComment(this.commentId, body);
+            else
+                this.commentId = await this.github.createComment(this.event.number, body);
+        });
+        if (!ok)
+            this.commentOn = false;
+    }
+    async startDeployment() {
+        if (!this.deploymentsOn)
+            return undefined;
+        let id;
+        const ok = await this.safe("GitHub deployment", async () => {
+            id = await this.github.createDeployment({
+                sha: this.sha,
+                environment: this.environment,
+                description: `Worker Preview of ${this.branch}`,
+                payload: { [PAYLOAD_KEY]: this.event.number },
+            });
+            await this.github.setDeploymentStatus(id, { state: "in_progress", logUrl: this.runUrl });
+        });
+        if (!ok)
+            this.deploymentsOn = false;
+        return id;
+    }
+    async deploymentStatus(id, args) {
+        if (id === undefined || !this.deploymentsOn)
+            return;
+        await this.safe("GitHub deployment status", () => this.github.setDeploymentStatus(id, { ...args, logUrl: this.runUrl }));
+    }
+    /**
+     * Transient deployments are never marked inactive automatically, so this PR's
+     * older ones are retired here. Other PRs share the environment.
+     */
+    async deactivateDeployments(keep) {
+        if (!this.deploymentsOn)
+            return;
+        await this.safe("GitHub deployment cleanup", async () => {
+            for (const { id, payload } of await this.github.listDeployments(this.environment)) {
+                if (id === keep || pullRequestOf(payload) !== this.event.number)
+                    continue;
+                if (await this.github.isInactive(id))
+                    continue;
+                await this.github.setDeploymentStatus(id, { state: "inactive" });
+            }
+        });
+    }
+    async safe(what, fn) {
+        try {
+            await fn();
+            return true;
+        }
+        catch (err) {
+            this.deps.runner.log(warning(`${what} skipped: ${err.message}`));
+            return false;
+        }
+    }
+}
+/** GitHub may hand back a deployment payload as a JSON string. */
+function pullRequestOf(payload) {
+    let value = payload;
+    if (typeof value === "string") {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const pr = value?.[PAYLOAD_KEY];
+    return typeof pr === "number" ? pr : undefined;
+}

package/dist/github.d.ts

@@ -0,0 +1,33 @@
+export type DeploymentState = "in_progress" | "success" | "failure" | "error" | "inactive";
+export type Deployment = {
+    id: number;
+    payload?: unknown;
+};
+export declare class GitHubApi {
+    private token;
+    private repo;
+    private fetchImpl;
+    private base;
+    constructor(token: string, repo: string, fetchImpl?: typeof fetch, base?: string);
+    private call;
+    private all;
+    /** The id of the first comment on the issue or PR whose body starts with `marker`. */
+    findComment(issue: number, marker: string): Promise<number | undefined>;
+    createComment(issue: number, body: string): Promise<number>;
+    updateComment(id: number, body: string): Promise<void>;
+    /** Skips the default merge and commit status checks, which would refuse a deployment while CI runs. */
+    createDeployment(args: {
+        sha: string;
+        environment: string;
+        description: string;
+        payload: Record<string, unknown>;
+    }): Promise<number>;
+    setDeploymentStatus(id: number, args: {
+        state: DeploymentState;
+        environmentUrl?: string;
+        logUrl?: string;
+        description?: string;
+    }): Promise<void>;
+    isInactive(id: number): Promise<boolean>;
+    listDeployments(environment: string): Promise<Deployment[]>;
+}

package/dist/github.js

@@ -0,0 +1,78 @@
+import { apiErrorMessage } from "./http.js";
+export class GitHubApi {
+    token;
+    repo;
+    fetchImpl;
+    base;
+    constructor(token, repo, fetchImpl = fetch, base = process.env.GITHUB_API_URL ?? "https://api.github.com") {
+        this.token = token;
+        this.repo = repo;
+        this.fetchImpl = fetchImpl;
+        this.base = base;
+    }
+    async call(method, path, body) {
+        const res = await this.fetchImpl(`${this.base}/repos/${this.repo}${path}`, {
+            method,
+            headers: {
+                authorization: `Bearer ${this.token}`,
+                accept: "application/vnd.github+json",
+                "x-github-api-version": "2022-11-28",
+                ...(body === undefined ? {} : { "content-type": "application/json" }),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(apiErrorMessage(`GitHub API ${method} ${path}`, res.status, await res.text(), "GITHUB_TOKEN"));
+        return (await res.json());
+    }
+    async all(path) {
+        const all = [];
+        const sep = path.includes("?") ? "&" : "?";
+        for (let page = 1;; page += 1) {
+            const batch = await this.call("GET", `${path}${sep}per_page=100&page=${page}`);
+            all.push(...batch);
+            if (batch.length < 100)
+                return all;
+        }
+    }
+    /** The id of the first comment on the issue or PR whose body starts with `marker`. */
+    async findComment(issue, marker) {
+        const comments = await this.all(`/issues/${issue}/comments`);
+        return comments.find((c) => c.body?.startsWith(marker))?.id;
+    }
+    async createComment(issue, body) {
+        return (await this.call("POST", `/issues/${issue}/comments`, { body })).id;
+    }
+    async updateComment(id, body) {
+        await this.call("PATCH", `/issues/comments/${id}`, { body });
+    }
+    /** Skips the default merge and commit status checks, which would refuse a deployment while CI runs. */
+    async createDeployment(args) {
+        const deployment = await this.call("POST", "/deployments", {
+            ref: args.sha,
+            environment: args.environment,
+            payload: args.payload,
+            description: args.description,
+            auto_merge: false,
+            required_contexts: [],
+            transient_environment: true,
+            production_environment: false,
+        });
+        return deployment.id;
+    }
+    async setDeploymentStatus(id, args) {
+        await this.call("POST", `/deployments/${id}/statuses`, {
+            state: args.state,
+            ...(args.environmentUrl ? { environment_url: args.environmentUrl } : {}),
+            ...(args.logUrl ? { log_url: args.logUrl } : {}),
+            ...(args.description ? { description: args.description.slice(0, 140) } : {}),
+        });
+    }
+    async isInactive(id) {
+        const statuses = await this.all(`/deployments/${id}/statuses`);
+        return statuses.some((s) => s.state === "inactive");
+    }
+    listDeployments(environment) {
+        return this.all(`/deployments?environment=${encodeURIComponent(environment)}`);
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,7 @@
+export declare const DOCS_URL = "https://github.com/mattruby/supabase-worker-previews#readme";
+export declare const QUICKSTART_URL = "https://github.com/mattruby/supabase-worker-previews/blob/main/docs/quickstart.md";
+export declare const TOKENS_URL = "https://github.com/mattruby/supabase-worker-previews/blob/main/docs/tokens.md";
+/** An API error body in one short line: the JSON message when there is one, else the text, cut. */
+export declare function summarizeBody(body: string, max?: number): string;
+/** `<prefix>: <status> <summary>`, plus what a 401 or 403 says about the token that made the call. */
+export declare function apiErrorMessage(prefix: string, status: number, body: string, variable: string): string;

package/dist/http.js

@@ -0,0 +1,44 @@
+const REPO = "https://github.com/mattruby/supabase-worker-previews";
+export const DOCS_URL = `${REPO}#readme`;
+export const QUICKSTART_URL = `${REPO}/blob/main/docs/quickstart.md`;
+export const TOKENS_URL = `${REPO}/blob/main/docs/tokens.md`;
+/** An API error body in one short line: the JSON message when there is one, else the text, cut. */
+export function summarizeBody(body, max = 200) {
+    let text = body;
+    try {
+        text = messageOf(JSON.parse(body)) ?? body;
+    }
+    catch {
+        const title = /<title>([^<]*)<\/title>/i.exec(body)?.[1];
+        if (title)
+            text = title;
+    }
+    text = text.replace(/\s+/g, " ").trim();
+    return text.length > max ? `${text.slice(0, max - 3)}...` : text;
+}
+function messageOf(json) {
+    if (!json || typeof json !== "object")
+        return undefined;
+    const o = json;
+    for (const value of [o.message, o.msg, o.error])
+        if (typeof value === "string" && value)
+            return value;
+    if (o.error && typeof o.error === "object")
+        return messageOf(o.error);
+    if (Array.isArray(o.errors)) {
+        const messages = o.errors.map(messageOf).filter((m) => m !== undefined);
+        if (messages.length)
+            return messages.join("; ");
+    }
+    return undefined;
+}
+/** `<prefix>: <status> <summary>`, plus what a 401 or 403 says about the token that made the call. */
+export function apiErrorMessage(prefix, status, body, variable) {
+    const summary = summarizeBody(body);
+    const line = `${prefix}: ${status}${summary ? ` ${summary}` : ""}`;
+    if (status === 401)
+        return `${line}. ${variable} is invalid or expired; see ${TOKENS_URL}`;
+    if (status === 403)
+        return `${line}. ${variable} lacks a permission this call needs; see ${TOKENS_URL}`;
+    return line;
+}

package/dist/jsonc.d.ts

@@ -0,0 +1,2 @@
+/** Parses JSON with comments and trailing commas, as wrangler.jsonc allows. */
+export declare function parseJsonc(text: string): unknown;

package/dist/jsonc.js

@@ -0,0 +1,56 @@
+/** Parses JSON with comments and trailing commas, as wrangler.jsonc allows. */
+export function parseJsonc(text) {
+    return JSON.parse(dropTrailingCommas(stripComments(text)));
+}
+function stripComments(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '"') {
+            const end = stringEnd(text, i);
+            out += text.slice(i, end);
+            i = end - 1;
+        }
+        else if (c === "/" && text[i + 1] === "/") {
+            while (i < text.length && text[i] !== "\n")
+                i++;
+            out += "\n";
+        }
+        else if (c === "/" && text[i + 1] === "*") {
+            const end = text.indexOf("*/", i + 2);
+            i = end === -1 ? text.length : end + 1;
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+function dropTrailingCommas(text) {
+    let out = "";
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (c === '"') {
+            const end = stringEnd(text, i);
+            out += text.slice(i, end);
+            i = end - 1;
+        }
+        else if (c === "," && /^\s*[}\]]/.test(text.slice(i + 1))) {
+            continue;
+        }
+        else {
+            out += c;
+        }
+    }
+    return out;
+}
+/** Index just past the string literal that opens at `start`. */
+function stringEnd(text, start) {
+    for (let i = start + 1; i < text.length; i++) {
+        if (text[i] === "\\")
+            i++;
+        else if (text[i] === '"')
+            return i + 1;
+    }
+    return text.length;
+}

package/dist/preview-name.d.ts

@@ -0,0 +1,3 @@
+/** A git branch as a DNS label, to match a Preview that was named by slug rather than by raw branch. */
+export declare function previewName(branch: string): string;
+export declare function previewWildcard(worker: string, subdomain: string): string;

package/dist/preview-name.js

@@ -0,0 +1,15 @@
+/** A git branch as a DNS label, to match a Preview that was named by slug rather than by raw branch. */
+export function previewName(branch) {
+    const name = branch
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40)
+        .replace(/-+$/, "");
+    if (!name)
+        throw new Error(`Cannot make a Preview name from branch "${branch}"`);
+    return name;
+}
+export function previewWildcard(worker, subdomain) {
+    return `https://*-${worker}.${subdomain}.workers.dev/**`;
+}

package/dist/run.d.ts

@@ -0,0 +1,21 @@
+export type ExecOptions = {
+    env?: Record<string, string>;
+    input?: string;
+    captureStderr?: boolean;
+};
+export type Runner = {
+    dryRun: boolean;
+    log: (line: string) => void;
+    /** Runs a command, or in dry-run mode only prints it. Throws on a non-zero exit. */
+    exec: (cmd: string, args: string[], opts?: ExecOptions) => string;
+};
+export declare function makeRunner(dryRun: boolean, log?: (line: string) => void): Runner;
+/**
+ * `--flag value`, `--flag=value` and bare `--flag`. A flag in `booleans` never
+ * takes the next argument, so `swp --dry-run up` keeps `up` as the command.
+ */
+export declare function parseArgs(argv: string[], booleans?: ReadonlySet<string>): {
+    positional: string[];
+    flags: Record<string, string | true>;
+};
+export declare const sleep: (ms: number) => Promise<void>;

package/dist/run.js

@@ -0,0 +1,59 @@
+import { spawnSync } from "node:child_process";
+export function makeRunner(dryRun, log = console.log) {
+    return {
+        dryRun,
+        log,
+        exec(cmd, args, opts) {
+            const shown = [cmd, ...args.map((a) => (/\s/.test(a) ? JSON.stringify(a) : a))].join(" ");
+            if (dryRun) {
+                log(`  $ ${shown}${opts?.input ? `  (stdin: ${opts.input.length} bytes)` : ""}`);
+                return "";
+            }
+            log(`  $ ${shown}`);
+            const res = spawnSync(cmd, args, {
+                encoding: "utf8",
+                env: { ...process.env, ...(opts?.env ?? {}) },
+                input: opts?.input,
+                stdio: [opts?.input ? "pipe" : "inherit", "pipe", opts?.captureStderr ? "pipe" : "inherit"],
+                maxBuffer: 64 * 1024 * 1024,
+            });
+            if (res.error)
+                throw res.error;
+            if (res.status !== 0) {
+                const tail = opts?.captureStderr ? (res.stderr ?? "").trim().split("\n").slice(-8).join("\n") : "";
+                throw new Error(`\`${shown}\` exited ${res.status}${tail ? `:\n${tail}` : ""}`);
+            }
+            return res.stdout ?? "";
+        },
+    };
+}
+/**
+ * `--flag value`, `--flag=value` and bare `--flag`. A flag in `booleans` never
+ * takes the next argument, so `swp --dry-run up` keeps `up` as the command.
+ */
+export function parseArgs(argv, booleans = new Set()) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-h")
+            flags.help = true;
+        else if (a === "-v")
+            flags.version = true;
+        else if (!a.startsWith("--"))
+            positional.push(a);
+        else {
+            const eq = a.indexOf("=");
+            const k = eq === -1 ? a.slice(2) : a.slice(2, eq);
+            const next = argv[i + 1];
+            if (eq !== -1)
+                flags[k] = a.slice(eq + 1);
+            else if (!booleans.has(k) && next !== undefined && !next.startsWith("-"))
+                flags[k] = argv[++i];
+            else
+                flags[k] = true;
+        }
+    }
+    return { positional, flags };
+}
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

package/dist/runtime.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Worker-side half: one build serves any Supabase database. The Worker reads
+ * its Supabase values at request time (from wrangler vars, or a Preview's
+ * SUPABASE_OVERRIDE secret) and hands the public ones to the browser, so a
+ * Preview never needs its own build.
+ */
+export declare const OVERRIDE_SECRET = "SUPABASE_OVERRIDE";
+export declare const DEFAULT_GLOBAL = "__SUPABASE_PUBLIC__";
+export declare const IDENTITY_PATH = "/.well-known/supabase-preview";
+export declare const SUPABASE_VARS: readonly ["SUPABASE_URL", "SUPABASE_PUBLISHABLE_KEY", "SUPABASE_SERVICE_ROLE_KEY", "SUPABASE_PROJECT_REF"];
+export type SupabaseValues = Record<(typeof SUPABASE_VARS)[number], string>;
+export type PublicConfig = {
+    supabaseUrl: string;
+    supabaseKey: string;
+};
+/**
+ * The override replaces all four values. It is one secret, not four, because a
+ * Worker var and secret must never share a name.
+ */
+export declare function parseOverride(raw: unknown): SupabaseValues | null;
+/**
+ * `env` with any SUPABASE_OVERRIDE applied. Also patches `process.env` when
+ * nodejs_compat provides it, for code that reads Supabase settings from there.
+ */
+export declare function resolveEnv<E extends object>(env: E): E;
+export declare function publicConfigFromEnv(env: object): PublicConfig | null;
+export declare function publicConfigScript(config: PublicConfig, globalName?: string): string;
+/** Browser side: the values the Worker injected, or null under a dev server that did not. */
+export declare function readPublicConfig(globalName?: string, scope?: object): PublicConfig | null;
+/** `https://<ref>.supabase.co` gives `<ref>`; a custom API domain gives null. */
+export declare function projectRefOf(url: string | undefined): string | null;
+export declare function injectIntoHtml(response: Response, html: string): Promise<Response>;
+export declare function identityResponse(env: object): Response;
+export type PreviewOptions = {
+    /** Window property the browser reads the public config from. */
+    globalName?: string;
+    /** Inject the public config into HTML responses. Default true. */
+    inject?: boolean;
+    /** Serve which database this deployment uses at /.well-known/supabase-preview. Default true. */
+    identity?: boolean;
+};
+/** Any Worker handler object, including `ExportedHandler<Env>`, whose `fetch` takes the workers `Request`. */
+type Handler = {
+    fetch?: (request: never, env: never, ctx: never) => unknown;
+};
+/** The env type a handler's `fetch` declares, so callers never pass it as a generic. */
+type EnvOf<H> = H extends {
+    fetch?: (request: never, env: infer E, ...rest: never[]) => unknown;
+} ? E & object : object;
+/**
+ * Wraps a Worker's default export. Every handler sees the override applied;
+ * `fetch` also injects the public config and answers the identity route that
+ * `swp check` reads.
+ */
+export declare function withSupabasePreviews<H extends object, E extends object = EnvOf<H>>(handler: H & Handler, options?: PreviewOptions): H;
+export {};