src/cloudflare.ts

Functions

Imports

It imports src/drill.ts, src/types.ts. Imported by src/cli.ts.

Source

1import { SCRATCH_PREFIX, type Scratch } from "./drill.js";
2import type { D1Like, D1Statement } from "./types.js";
3
4// A scratch D1 database reached over Cloudflare's REST API, for a drill run from Node
5// or CI where there is no binding. Needs an API token that can create and delete D1
6// databases on the account; the token is sent only as the Authorization header and never
7// appears in an error.
8//
9// A BLOB cannot be bound over REST (JSON has no bytes), so a table holding one fails the
10// drill with a named error rather than restoring it as a different type.
11
12const API = "https://api.cloudflare.com/client/v4";
13
14interface Envelope<T> {
15  success: boolean;
16  result: T;
17  errors?: Array<{ code?: number; message?: string }>;
18}
19
20interface Query {
21  sql: string;
22  params: unknown[];
23}
24
25class RestStatement implements D1Statement {
26  constructor(
27    private readonly run_: (queries: Query[]) => Promise<Array<{ results: unknown[] }>>,
28    readonly query: Query
29  ) {}
30  bind(...values: unknown[]): D1Statement {
31    for (const v of values) {
32      if (Array.isArray(v)) throw new Error("d1-dump: the REST API cannot bind a BLOB, so a table holding one cannot be drilled over REST");
33    }
34    return new RestStatement(this.run_, { sql: this.query.sql, params: values });
35  }
36  async all<T = Record<string, unknown>>(): Promise<{ results: T[] }> {
37    const [first] = await this.run_([this.query]);
38    return { results: (first?.results ?? []) as T[] };
39  }
40  async run(): Promise<unknown> {
41    return (await this.run_([this.query]))[0];
42  }
43}
44
45export function cloudflareScratch(accountId: string, apiToken: string, fetchImpl: typeof fetch = fetch): (name: string) => Promise<Scratch> {
46  const call = async <T>(method: string, path: string, body?: unknown): Promise<T> => {
47    const res = await fetchImpl(`${API}/accounts/${accountId}${path}`, {
48      method,
49      headers: { authorization: `Bearer ${apiToken}`, "content-type": "application/json" },
50      body: body === undefined ? undefined : JSON.stringify(body),
51    });
52    const text = await res.text();
53    let parsed: Envelope<T>;
54    try {
55      parsed = JSON.parse(text) as Envelope<T>;
56    } catch {
57      throw new Error(`d1-dump: ${method} ${path} answered ${res.status} with a body that is not JSON`);
58    }
59    if (!res.ok || !parsed.success) {
60      const why = (parsed.errors ?? []).map((e) => e.message ?? String(e.code)).join("; ");
61      throw new Error(`d1-dump: ${method} ${path} failed (${res.status}): ${why || "no error given"}`);
62    }
63    return parsed.result;
64  };
65
66  return async (name) => {
67    // The one place a database is created or deleted, so nothing else can be touched.
68    if (!name.startsWith(SCRATCH_PREFIX)) throw new Error(`d1-dump: refusing to create ${JSON.stringify(name)}: a scratch database starts with ${SCRATCH_PREFIX}`);
69    const created = await call<{ uuid: string }>("POST", "/d1/database", { name });
70    const id = created.uuid;
71    const send = async (queries: Query[]) => {
72      const body = queries.length === 1 ? queries[0] : { batch: queries };
73      return call<Array<{ results: unknown[] }>>("POST", `/d1/database/${id}/query`, body);
74    };
75    const db: D1Like = {
76      prepare: (sql) => new RestStatement(send, { sql, params: [] }),
77      batch: async <T>(statements: D1Statement[]) => {
78        const queries = statements.map((s) => (s as RestStatement).query);
79        return (await send(queries)) as Array<{ results: T[] }>;
80      },
81    };
82    return { db, delete: async () => void (await call("DELETE", `/d1/database/${id}`)) };
83  };
84}