@motherbase/cli 0.2.4 → 0.2.6

package/src/config.js

@@ -1,98 +1,98 @@
-'use strict';
-
-// Config persistence. Two files:
-//   Global creds : ~/.motherbase/config.json  (contains tokens; written 0o600)
-//     { "consoles": { "<url>": { "token": "...", "email": "..." } }, "current": "<url>" }
-//   Project link : ./.motherbase/config.json  (versionable, non-secret)
-//     { "consoleUrl": "<url>", "projectId": "abc", "projectName": "my-app" }
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const GLOBAL_DIR = path.join(os.homedir(), '.motherbase');
-const GLOBAL_FILE = path.join(GLOBAL_DIR, 'config.json');
-const LINK_DIRNAME = '.motherbase';
-const LINK_BASENAME = 'config.json';
-
-function normalizeUrl(url) {
-  return String(url || '').replace(/\/+$/, '');
-}
-
-function readJson(file) {
-  try {
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch {
-    return null;
-  }
-}
-
-// ── Global credentials ───────────────────────────────────────────────────────
-
-function readGlobal() {
-  return readJson(GLOBAL_FILE) || { consoles: {}, current: null };
-}
-
-function writeGlobal(cfg) {
-  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
-  fs.writeFileSync(GLOBAL_FILE, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
-  // Best-effort tighten perms even if the file already existed with looser mode.
-  try { fs.chmodSync(GLOBAL_FILE, 0o600); } catch { /* windows / noop */ }
-}
-
-function saveConsoleToken(url, token, email) {
-  const u = normalizeUrl(url);
-  const cfg = readGlobal();
-  cfg.consoles = cfg.consoles || {};
-  cfg.consoles[u] = { ...(cfg.consoles[u] || {}), token, email };
-  cfg.current = u;
-  writeGlobal(cfg);
-  return u;
-}
-
-function clearConsoleToken(url) {
-  const cfg = readGlobal();
-  const u = normalizeUrl(url);
-  if (cfg.consoles && cfg.consoles[u]) delete cfg.consoles[u];
-  if (cfg.current === u) cfg.current = null;
-  writeGlobal(cfg);
-}
-
-function consoleEntry(url) {
-  const cfg = readGlobal();
-  return (cfg.consoles && cfg.consoles[normalizeUrl(url)]) || null;
-}
-
-// ── Per-project link ─────────────────────────────────────────────────────────
-
-function linkPath(cwd) {
-  return path.join(cwd || process.cwd(), LINK_DIRNAME, LINK_BASENAME);
-}
-
-function readLink(cwd) {
-  return readJson(linkPath(cwd));
-}
-
-function writeLink(cwd, data) {
-  const dir = path.join(cwd || process.cwd(), LINK_DIRNAME);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(linkPath(cwd), JSON.stringify(data, null, 2) + '\n');
-}
-
-function removeLink(cwd) {
-  try { fs.unlinkSync(linkPath(cwd)); return true; } catch { return false; }
-}
-
-module.exports = {
-  GLOBAL_FILE,
-  normalizeUrl,
-  readGlobal,
-  writeGlobal,
-  saveConsoleToken,
-  clearConsoleToken,
-  consoleEntry,
-  readLink,
-  writeLink,
-  removeLink,
-  linkPath,
-};
+'use strict';
+
+// Config persistence. Two files:
+//   Global creds : ~/.motherbase/config.json  (contains tokens; written 0o600)
+//     { "consoles": { "<url>": { "token": "...", "email": "..." } }, "current": "<url>" }
+//   Project link : ./.motherbase/config.json  (versionable, non-secret)
+//     { "consoleUrl": "<url>", "projectId": "abc", "projectName": "my-app" }
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const GLOBAL_DIR = path.join(os.homedir(), '.motherbase');
+const GLOBAL_FILE = path.join(GLOBAL_DIR, 'config.json');
+const LINK_DIRNAME = '.motherbase';
+const LINK_BASENAME = 'config.json';
+
+function normalizeUrl(url) {
+  return String(url || '').replace(/\/+$/, '');
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+// ── Global credentials ───────────────────────────────────────────────────────
+
+function readGlobal() {
+  return readJson(GLOBAL_FILE) || { consoles: {}, current: null };
+}
+
+function writeGlobal(cfg) {
+  fs.mkdirSync(GLOBAL_DIR, { recursive: true });
+  fs.writeFileSync(GLOBAL_FILE, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
+  // Best-effort tighten perms even if the file already existed with looser mode.
+  try { fs.chmodSync(GLOBAL_FILE, 0o600); } catch { /* windows / noop */ }
+}
+
+function saveConsoleToken(url, token, email) {
+  const u = normalizeUrl(url);
+  const cfg = readGlobal();
+  cfg.consoles = cfg.consoles || {};
+  cfg.consoles[u] = { ...(cfg.consoles[u] || {}), token, email };
+  cfg.current = u;
+  writeGlobal(cfg);
+  return u;
+}
+
+function clearConsoleToken(url) {
+  const cfg = readGlobal();
+  const u = normalizeUrl(url);
+  if (cfg.consoles && cfg.consoles[u]) delete cfg.consoles[u];
+  if (cfg.current === u) cfg.current = null;
+  writeGlobal(cfg);
+}
+
+function consoleEntry(url) {
+  const cfg = readGlobal();
+  return (cfg.consoles && cfg.consoles[normalizeUrl(url)]) || null;
+}
+
+// ── Per-project link ─────────────────────────────────────────────────────────
+
+function linkPath(cwd) {
+  return path.join(cwd || process.cwd(), LINK_DIRNAME, LINK_BASENAME);
+}
+
+function readLink(cwd) {
+  return readJson(linkPath(cwd));
+}
+
+function writeLink(cwd, data) {
+  const dir = path.join(cwd || process.cwd(), LINK_DIRNAME);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(linkPath(cwd), JSON.stringify(data, null, 2) + '\n');
+}
+
+function removeLink(cwd) {
+  try { fs.unlinkSync(linkPath(cwd)); return true; } catch { return false; }
+}
+
+module.exports = {
+  GLOBAL_FILE,
+  normalizeUrl,
+  readGlobal,
+  writeGlobal,
+  saveConsoleToken,
+  clearConsoleToken,
+  consoleEntry,
+  readLink,
+  writeLink,
+  removeLink,
+  linkPath,
+};

package/src/context.js

@@ -1,102 +1,106 @@
-'use strict';
-
-// Resolve the runtime context: which console, which token, which project, and
-// whether we talk through the Console proxy ('console' mode) or straight at a
-// single project API ('direct' mode). Precedence everywhere: flags > env > config.
-//
-// Resolution is LAZY: building a context never throws, so commands that need no
-// project (login, local docker, init) work with zero configuration. The
-// require*() helpers throw a clear, actionable error only when a value is
-// actually needed and missing.
-
-const config = require('./config');
-
-class CliError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'CliError';
-    this.isCliError = true;
-  }
-}
-
-function firstDefined(...vals) {
-  for (const v of vals) if (v !== undefined && v !== null && v !== '') return v;
-  return undefined;
-}
-
-function createContext(flags = {}, env = process.env, cwd = process.cwd()) {
-  const link = config.readLink(cwd) || {};
-  const global = config.readGlobal();
-
-  const consoleUrl = firstDefined(
-    flags.url,
-    env.MOTHERBASE_CONSOLE_URL,
-    link.consoleUrl,
-    global.current,
-  );
-  const normConsoleUrl = consoleUrl ? config.normalizeUrl(consoleUrl) : undefined;
-
-  const token = firstDefined(
-    flags.token,
-    env.MOTHERBASE_TOKEN,
-    normConsoleUrl ? (config.consoleEntry(normConsoleUrl) || {}).token : undefined,
-  );
-
-  const projectId = firstDefined(flags.project, env.MOTHERBASE_PROJECT, link.projectId);
-  const projectName = firstDefined(link.projectName, projectId);
-
-  // Direct project mode: an admin JWT pointed straight at one project API. Only
-  // used as a fallback when there is no console link/flags to route through.
-  const directUrl = env.MOTHERBASE_URL ? config.normalizeUrl(env.MOTHERBASE_URL) : undefined;
-  const directToken = env.MOTHERBASE_ADMIN_TOKEN;
-  const hasConsole = Boolean(normConsoleUrl && token);
-  const hasProjectLink = Boolean(projectId);
-  const preferDirect = Boolean(directUrl && directToken) && !(hasConsole && hasProjectLink);
-  const mode = preferDirect ? 'direct' : 'console';
-
-  return {
-    flags,
-    env,
-    cwd,
-    mode,
-    consoleUrl: normConsoleUrl,
-    token,
-    projectId,
-    projectName,
-    directUrl,
-    directToken,
-    linkedConsoleUrl: link.consoleUrl,
-    accountEmail: normConsoleUrl ? (config.consoleEntry(normConsoleUrl) || {}).email : undefined,
-
-    // Console (account / multi-project) requests need URL + session token.
-    requireConsole() {
-      if (!this.consoleUrl) {
-        throw new CliError('No console URL. Run `motherbase login --url <consoleUrl>` or set MOTHERBASE_CONSOLE_URL.');
-      }
-      if (!this.token) {
-        throw new CliError('Not logged in. Run `motherbase login` or set MOTHERBASE_TOKEN.');
-      }
-      return { consoleUrl: this.consoleUrl, token: this.token };
-    },
-
-    // Admin/resource requests: resolve either the console proxy path or a direct
-    // project API, whichever the context selected.
-    requireProject() {
-      if (this.mode === 'direct') {
-        return { mode: 'direct', baseUrl: this.directUrl, token: this.directToken };
-      }
-      this.requireConsole();
-      if (!this.projectId) {
-        throw new CliError('No project linked. Run `motherbase link` or set MOTHERBASE_PROJECT (or use direct mode via MOTHERBASE_URL + MOTHERBASE_ADMIN_TOKEN).');
-      }
-      return {
-        mode: 'console',
-        consoleUrl: this.consoleUrl,
-        token: this.token,
-        projectId: this.projectId,
-      };
-    },
-  };
-}
-
-module.exports = { createContext, CliError };
+'use strict';
+
+// Resolve the runtime context: which console, which token, which project, and
+// whether we talk through the Console proxy ('console' mode) or straight at a
+// single project API ('direct' mode). Precedence everywhere: flags > env > config.
+//
+// Resolution is LAZY: building a context never throws, so commands that need no
+// project (login, local docker, init) work with zero configuration. The
+// require*() helpers throw a clear, actionable error only when a value is
+// actually needed and missing.
+
+const config = require('./config');
+
+class CliError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CliError';
+    this.isCliError = true;
+  }
+}
+
+function firstDefined(...vals) {
+  for (const v of vals) if (v !== undefined && v !== null && v !== '') return v;
+  return undefined;
+}
+
+function createContext(flags = {}, env = process.env, cwd = process.cwd()) {
+  const link = config.readLink(cwd) || {};
+  const global = config.readGlobal();
+
+  const consoleUrl = firstDefined(
+    flags.url,
+    env.MOTHERBASE_CONSOLE_URL,
+    link.consoleUrl,
+    global.current,
+  );
+  const normConsoleUrl = consoleUrl ? config.normalizeUrl(consoleUrl) : undefined;
+
+  // The link file is committed to the repo, so a URL that came only from it is
+  // not trusted with a token the user supplied for some other console.
+  const urlFromLinkOnly = !firstDefined(flags.url, env.MOTHERBASE_CONSOLE_URL) && Boolean(link.consoleUrl);
+
+  const token = firstDefined(
+    urlFromLinkOnly ? undefined : flags.token,
+    urlFromLinkOnly ? undefined : env.MOTHERBASE_TOKEN,
+    normConsoleUrl ? (config.consoleEntry(normConsoleUrl) || {}).token : undefined,
+  );
+
+  const projectId = firstDefined(flags.project, env.MOTHERBASE_PROJECT, link.projectId);
+  const projectName = firstDefined(link.projectName, projectId);
+
+  // Direct project mode: an admin JWT pointed straight at one project API. Only
+  // used as a fallback when there is no console link/flags to route through.
+  const directUrl = env.MOTHERBASE_URL ? config.normalizeUrl(env.MOTHERBASE_URL) : undefined;
+  const directToken = env.MOTHERBASE_ADMIN_TOKEN;
+  const hasConsole = Boolean(normConsoleUrl && token);
+  const hasProjectLink = Boolean(projectId);
+  const preferDirect = Boolean(directUrl && directToken) && !(hasConsole && hasProjectLink);
+  const mode = preferDirect ? 'direct' : 'console';
+
+  return {
+    flags,
+    env,
+    cwd,
+    mode,
+    consoleUrl: normConsoleUrl,
+    token,
+    projectId,
+    projectName,
+    directUrl,
+    directToken,
+    linkedConsoleUrl: link.consoleUrl,
+    accountEmail: normConsoleUrl ? (config.consoleEntry(normConsoleUrl) || {}).email : undefined,
+
+    // Console (account / multi-project) requests need URL + session token.
+    requireConsole() {
+      if (!this.consoleUrl) {
+        throw new CliError('No console URL. Run `motherbase login --url <consoleUrl>` or set MOTHERBASE_CONSOLE_URL.');
+      }
+      if (!this.token) {
+        throw new CliError('Not logged in. Run `motherbase login` or set MOTHERBASE_TOKEN.');
+      }
+      return { consoleUrl: this.consoleUrl, token: this.token };
+    },
+
+    // Admin/resource requests: resolve either the console proxy path or a direct
+    // project API, whichever the context selected.
+    requireProject() {
+      if (this.mode === 'direct') {
+        return { mode: 'direct', baseUrl: this.directUrl, token: this.directToken };
+      }
+      this.requireConsole();
+      if (!this.projectId) {
+        throw new CliError('No project linked. Run `motherbase link` or set MOTHERBASE_PROJECT (or use direct mode via MOTHERBASE_URL + MOTHERBASE_ADMIN_TOKEN).');
+      }
+      return {
+        mode: 'console',
+        consoleUrl: this.consoleUrl,
+        token: this.token,
+        projectId: this.projectId,
+      };
+    },
+  };
+}
+
+module.exports = { createContext, CliError };

package/src/docs.js

@@ -0,0 +1,68 @@
+'use strict';
+
+// Renders the command registry as the Markdown table published in the docs.
+//
+// `main.js` already builds every help screen from `registry` + `groups`, so the
+// terminal could never disagree with the code. The published CLI reference
+// could, and did: thirteen whole groups (`orgs`, `branches`, `domains`,
+// `vanity-subdomains`, `backups`, `test`, `postgres-config`, `queues`, `vault`,
+// `wrappers`, `network-restrictions`, `ssl-enforcement`, `snippets`) existed in
+// `motherbase --help` and not in the reference, so the documented CLI was a
+// strict subset of the shipped one.
+//
+// Writing it from the same two objects the help screens use is what stops that
+// happening again. `scripts/generate-cli-docs.js` writes the file;
+// `test/docs.test.js` fails when the committed copy no longer matches.
+
+const { registry, groups } = require('./commands');
+
+/** Escape the pipe so a usage string containing one cannot break the table. */
+const cell = value => String(value ?? '').replace(/\|/g, '\\|');
+
+/** `motherbase db sql -e <sql>` → `` `motherbase db sql` `` plus its arguments. */
+function usageCell(usage) {
+  return usage ? `\`${cell(usage)}\`` : '—';
+}
+
+/**
+ * Commands in group order, then whatever the registry holds that no group
+ * names. A command with no group still renders: adding one to the registry and
+ * forgetting the group list must not make it vanish from the docs.
+ */
+function sections() {
+  const grouped = new Set(groups.flatMap(group => group.names));
+  const ungrouped = Object.keys(registry).filter(name => !grouped.has(name));
+  const all = groups.map(group => ({ title: group.title, names: group.names }));
+  if (ungrouped.length) all.push({ title: 'Ungrouped', names: ungrouped });
+  return all;
+}
+
+function renderCommandDocs() {
+  const lines = [
+    '<!-- GENERATED by `npm run docs:cli` from packages/cli/src/commands. Do not edit by hand. -->',
+    '',
+  ];
+
+  for (const section of sections()) {
+    const entries = section.names.map(name => [name, registry[name]]).filter(([, entry]) => entry);
+    if (!entries.length) continue;
+
+    lines.push(`### ${section.title}`, '');
+    lines.push('| Command | Usage | What it does |');
+    lines.push('|---|---|---|');
+
+    for (const [name, entry] of entries) {
+      lines.push(`| \`${cell(name)}\` | ${usageCell(entry.usage)} | ${cell(entry.summary)} |`);
+      for (const [sub, subEntry] of Object.entries(entry.subcommands ?? {})) {
+        lines.push(
+          `| \`${cell(name)} ${cell(sub)}\` | ${usageCell(subEntry.usage)} | ${cell(subEntry.summary)} |`,
+        );
+      }
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { renderCommandDocs };

package/src/edge-templates.js

@@ -0,0 +1,194 @@
+'use strict';
+
+// Starting points for `motherbase functions new --template <id>`. Pure data.
+// The Studio's "new function" picker offers the same list
+// (apps/studio/src/features/api-tools/lib/function-templates.ts): keep the ids
+// and sources in step.
+//
+// Every source is a module-shaped function (`export default handler`) that runs
+// on the Deno edge runtime. `%NAME%` is replaced with the function's name.
+
+const templates = [
+  {
+    id: 'hello-world',
+    label: 'Hello world',
+    description: 'Echo the request body and the time.',
+    source: `// Edge function: %NAME%
+//
+// Runs on Deno with the whole Web platform: Request, Response, fetch, streams,
+// crypto.subtle (for webhook signature checks) and friends. npm:, jsr: and URL
+// imports load as they do on Deno; a bare package name is read as npm:
+//
+//   import { z } from 'zod';
+//
+// \`env\` holds this project's edge secrets, and \`sendMail()\` sends through the
+// project's own SMTP settings (the same transport auth uses):
+//
+//   await sendMail({ to: 'sales@example.com', subject: 'New lead', text: '...' });
+
+export default async (req: Request) => {
+  const body = req.method === 'GET' ? {} : await req.json().catch(() => ({}));
+  return Response.json({ hello: '%NAME%', received: body, at: new Date().toISOString() });
+};
+`,
+  },
+  {
+    id: 'stripe-webhook',
+    label: 'Stripe webhook',
+    description: 'Verify a Stripe signature, then handle the event.',
+    source: `// Edge function: %NAME%
+// Secrets to set: STRIPE_WEBHOOK_SECRET (the endpoint's "whsec_..." signing secret).
+
+const encoder = new TextEncoder();
+
+async function sign(secret: string, payload: string): Promise<string> {
+  const key = await crypto.subtle.importKey('raw', encoder.encode(secret), { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+  const mac = await crypto.subtle.sign('HMAC', key, encoder.encode(payload));
+  return [...new Uint8Array(mac)].map(byte => byte.toString(16).padStart(2, '0')).join('');
+}
+
+export default async (req: Request) => {
+  // The raw body: a re-serialised one no longer matches the signature.
+  const payload = await req.text();
+  const header = req.headers.get('stripe-signature') ?? '';
+  const parts = Object.fromEntries(header.split(',').map(part => part.split('=') as [string, string]));
+  const expected = await sign(env.STRIPE_WEBHOOK_SECRET, \`\${parts.t}.\${payload}\`);
+  if (!parts.v1 || parts.v1 !== expected) return new Response('Invalid signature', { status: 400 });
+
+  const event = JSON.parse(payload);
+  switch (event.type) {
+    case 'checkout.session.completed':
+      console.log('checkout completed', event.data.object.id);
+      break;
+    default:
+      console.log('ignored event', event.type);
+  }
+  return Response.json({ received: true });
+};
+`,
+  },
+  {
+    id: 'openai',
+    label: 'OpenAI',
+    description: 'Send a prompt to OpenAI and return the answer.',
+    source: `// Edge function: %NAME%
+// Secrets to set: OPENAI_API_KEY.
+
+export default async (req: Request) => {
+  const { prompt } = await req.json();
+  if (typeof prompt !== 'string' || !prompt) return Response.json({ error: 'prompt is required' }, { status: 400 });
+
+  const response = await fetch('https://api.openai.com/v1/chat/completions', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: \`Bearer \${env.OPENAI_API_KEY}\` },
+    body: JSON.stringify({ model: 'gpt-4o-mini', messages: [{ role: 'user', content: prompt }] }),
+  });
+  if (!response.ok) return Response.json({ error: 'OpenAI request failed' }, { status: 502 });
+
+  const completion = await response.json();
+  return Response.json({ answer: completion.choices[0].message.content });
+};
+`,
+  },
+  {
+    id: 'resend-email',
+    label: 'Send email',
+    description: 'Send a transactional email with Resend, or with sendMail.',
+    source: `// Edge function: %NAME%
+// Secrets to set: RESEND_API_KEY. Prefer this project's own SMTP? Replace the
+// fetch below with: await sendMail({ to, subject, html });
+
+export default async (req: Request) => {
+  const { to, subject, html } = await req.json();
+  if (!to || !subject || !html) return Response.json({ error: 'to, subject and html are required' }, { status: 400 });
+
+  const response = await fetch('https://api.resend.com/emails', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: \`Bearer \${env.RESEND_API_KEY}\` },
+    body: JSON.stringify({ from: 'Acme <onboarding@resend.dev>', to, subject, html }),
+  });
+  return Response.json(await response.json(), { status: response.ok ? 200 : 502 });
+};
+`,
+  },
+  {
+    id: 'image-transform',
+    label: 'Image transform',
+    description: 'Resize an image fetched from a URL.',
+    source: `// Edge function: %NAME%
+// GET ?url=<image>&width=<px>. Uses ImageScript, a pure-JS image library.
+
+import { Image } from 'npm:imagescript@1';
+
+export default async (req: Request) => {
+  const params = new URL(req.url).searchParams;
+  const source = params.get('url');
+  const width = Math.min(Number(params.get('width') ?? 320), 2000);
+  if (!source || !Number.isFinite(width) || width < 1) return new Response('url and a positive width are required', { status: 400 });
+
+  const upstream = await fetch(source);
+  if (!upstream.ok) return new Response('Could not fetch the image', { status: 502 });
+
+  const image = await Image.decode(new Uint8Array(await upstream.arrayBuffer()));
+  const resized = image.resize(width, Image.RESIZE_AUTO);
+  return new Response(await resized.encode(), { headers: { 'content-type': 'image/png' } });
+};
+`,
+  },
+  {
+    id: 'websocket',
+    label: 'WebSocket',
+    description: 'Upgrade the request and echo every message.',
+    source: `// Edge function: %NAME%
+
+export default (req: Request) => {
+  if (req.headers.get('upgrade') !== 'websocket') return new Response('Expected a WebSocket upgrade', { status: 426 });
+
+  const { socket, response } = Deno.upgradeWebSocket(req);
+  socket.onopen = () => console.log('client connected');
+  socket.onmessage = event => socket.send(\`echo: \${event.data}\`);
+  socket.onclose = () => console.log('client disconnected');
+  return response;
+};
+`,
+  },
+  {
+    id: 'storage-upload',
+    label: 'Storage upload',
+    description: 'Store a request body as a file in Storage.',
+    source: `// Edge function: %NAME%
+// Secrets to set: SERVICE_TOKEN (a token allowed to write files). API_URL is
+// optional and defaults to this project's own API.
+
+export default async (req: Request) => {
+  const { path, text } = await req.json();
+  if (!path || typeof text !== 'string') return Response.json({ error: 'path and text are required' }, { status: 400 });
+
+  const form = new FormData();
+  form.append('file', new Blob([text], { type: 'text/plain' }), path);
+  form.append('path', path);
+
+  const response = await fetch(\`\${env.API_URL ?? 'http://api:5001'}/api/files/\`, {
+    method: 'POST',
+    headers: { authorization: \`Bearer \${env.SERVICE_TOKEN}\` },
+    body: form,
+  });
+  return Response.json(await response.json(), { status: response.ok ? 200 : 502 });
+};
+`,
+  },
+];
+
+const DEFAULT_TEMPLATE = 'hello-world';
+
+/** The template with this id, or undefined. */
+function findTemplate(id) {
+  return templates.find(template => template.id === id);
+}
+
+/** The source of a template for a function of this name. */
+function renderTemplate(template, name) {
+  return template.source.replace(/%NAME%/g, name);
+}
+
+module.exports = { templates, DEFAULT_TEMPLATE, findTemplate, renderTemplate };