@motherbase/cli 0.2.4 → 0.2.5

package/src/commands/functions.js

@@ -1,274 +1,297 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const api = require('../api');
-const ui = require('../ui');
-const { output, requireArg } = require('./_util');
-const { CliError } = require('../context');
-
-// Functions live as repo files, one directory per function, the layout Supabase
-// projects already use:
-//
-//   functions/
-//     stripe-webhook/
-//       index.ts
-//
-// The directory name is both the function name and its route, so deploying is
-// `motherbase functions deploy` with nothing to remember.
-const DEFAULT_DIR = 'functions';
-const LEGACY_DIR = path.join('motherbase', 'functions');
-const ENTRY_NAMES = ['index.ts', 'index.js', 'index.mjs'];
-
-const TEMPLATE = `// Edge function: %NAME%
-//
-// Runs in a V8 isolate with the Fetch API available: Request, Response,
-// Headers, URL, TextEncoder/TextDecoder and crypto (including subtle.sign, for
-// webhook signature checks). npm imports are resolved at deploy time:
-//
-//   import { z } from 'zod';
-//
-// \`env\` holds this project's edge secrets.
-
-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() });
-};
-`;
-
-function functionsDir(ctx) {
-  for (const candidate of [DEFAULT_DIR, LEGACY_DIR]) {
-    if (fs.existsSync(path.join(ctx.cwd, candidate))) return path.join(ctx.cwd, candidate);
-  }
-  return path.join(ctx.cwd, DEFAULT_DIR);
-}
-
-/** Entry file of a function directory, or null when it has none. */
-function entryFile(dir) {
-  for (const name of ENTRY_NAMES) {
-    const file = path.join(dir, name);
-    if (fs.existsSync(file)) return file;
-  }
-  return null;
-}
-
-/** Every locally defined function: `{ name, dir, entry }`. */
-function localFunctions(ctx) {
-  const root = functionsDir(ctx);
-  if (!fs.existsSync(root)) return [];
-  return fs
-    .readdirSync(root, { withFileTypes: true })
-    .filter(item => item.isDirectory())
-    .map(item => ({ name: item.name, dir: path.join(root, item.name), entry: entryFile(path.join(root, item.name)) }))
-    .filter(fn => fn.entry);
-}
-
-function resolveLocal(ctx, name) {
-  const all = localFunctions(ctx);
-  if (!name) return all;
-  const hit = all.find(fn => fn.name === name);
-  if (!hit) {
-    const expected = path.relative(ctx.cwd, path.join(functionsDir(ctx), name, 'index.ts'));
-    throw new CliError(`No local function "${name}". Expected ${expected}.`);
-  }
-  return [hit];
-}
-
-/** Upsert by route, so deploying twice updates instead of conflicting. */
-async function deployOne(ctx, fn, flags) {
-  const code = fs.readFileSync(fn.entry, 'utf8');
-  const body = { name: fn.name, route: fn.name, code };
-  if (flags && flags.memory) body.memoryLimitMb = Number(flags.memory);
-  if (flags && flags.timeout) body.timeoutMs = Number(flags.timeout);
-
-  const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
-  const existing = ((listing && listing.functions) || []).find(f => f.route === fn.name);
-  if (existing) return api.adminRequest(ctx, 'PATCH', `/edge-functions/${existing.id}`, { body });
-  return api.adminRequest(ctx, 'POST', '/edge-functions', { body: { ...body, enabled: true } });
-}
-
-const subcommands = {
-  list: {
-    summary: 'List edge functions',
-    usage: 'motherbase functions list',
-    async run(ctx) {
-      const data = await api.adminRequest(ctx, 'GET', '/edge-functions');
-      const rows = (data && data.functions) || [];
-      output(ctx, data, (_d, u) =>
-        u.table(rows, [
-          { key: 'id', label: 'ID' },
-          { key: 'name', label: 'NAME' },
-          { key: 'route', label: 'ROUTE' },
-          { key: 'enabled', label: 'ENABLED' },
-        ]),
-      );
-    },
-  },
-  get: {
-    summary: 'Get an edge function by id',
-    usage: 'motherbase functions get <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'GET', `/edge-functions/${id}`);
-      output(ctx, data, (d, u) => u.keyValue((d && d.function) || d || {}));
-    },
-  },
-  new: {
-    summary: 'Scaffold functions/<name>/index.ts',
-    usage: 'motherbase functions new <name>',
-    async run(ctx, args) {
-      const name = requireArg(args[0], 'name');
-      if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
-        throw new CliError('Function names are lowercase letters, digits and hyphens (the name is also the route).');
-      }
-      const dir = path.join(functionsDir(ctx), name);
-      if (entryFile(dir)) throw new CliError(`${path.relative(ctx.cwd, dir)} already has an entry file.`);
-      fs.mkdirSync(dir, { recursive: true });
-      const file = path.join(dir, 'index.ts');
-      fs.writeFileSync(file, TEMPLATE.replace(/%NAME%/g, name));
-      ui.success(`Created ${path.relative(ctx.cwd, file)}`);
-      ui.info(`Deploy it with: motherbase functions deploy ${name}`);
-    },
-  },
-  deploy: {
-    summary: 'Deploy local functions (all of them, or one by name)',
-    usage: 'motherbase functions deploy [name] [--memory <mb>] [--timeout <ms>] [--file <f> --route <r>]',
-    async run(ctx, args, flags) {
-      // The single-file form predates the directory layout and stays supported:
-      // scripts and older docs pass --file.
-      if (flags.file) {
-        const route = flags.route || args[0];
-        if (!route) throw new CliError('--route is required with --file');
-        const code = fs.readFileSync(path.resolve(ctx.cwd, flags.file), 'utf8');
-        const name = flags.name || route;
-        const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
-        const existing = ((listing && listing.functions) || []).find(f => f.route === route);
-        const data = existing
-          ? await api.adminRequest(ctx, 'PATCH', `/edge-functions/${existing.id}`, { body: { name, route, code } })
-          : await api.adminRequest(ctx, 'POST', '/edge-functions', { body: { name, route, code, enabled: true } });
-        return output(ctx, data, (_d, u) => u.success(`Deployed function ${name} (${route})`));
-      }
-
-      const targets = resolveLocal(ctx, args[0]);
-      if (!targets.length) {
-        const where = path.relative(ctx.cwd, functionsDir(ctx));
-        throw new CliError(`No functions in ${where}. Create one with: motherbase functions new <name>`);
-      }
-
-      const deployed = [];
-      for (const fn of targets) {
-        await deployOne(ctx, fn, flags);
-        deployed.push(fn.name);
-      }
-      output(ctx, { deployed }, (_d, u) => u.success(`Deployed ${deployed.join(', ')}`));
-    },
-  },
-  pull: {
-    summary: 'Write deployed function source back to disk',
-    usage: 'motherbase functions pull [name]',
-    async run(ctx, args) {
-      const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
-      const all = (listing && listing.functions) || [];
-      const wanted = args[0] ? all.filter(f => f.route === args[0] || f.name === args[0]) : all;
-      if (!wanted.length) throw new CliError(args[0] ? `No deployed function "${args[0]}"` : 'No deployed functions');
-
-      const written = [];
-      for (const fn of wanted) {
-        // The list endpoint may omit code, so read the function itself.
-        const detail = await api.adminRequest(ctx, 'GET', `/edge-functions/${fn.id}`);
-        const code = (detail && detail.function ? detail.function.code : detail && detail.code) || '';
-        const dir = path.join(functionsDir(ctx), fn.route || fn.name);
-        fs.mkdirSync(dir, { recursive: true });
-        const file = path.join(dir, 'index.ts');
-        fs.writeFileSync(file, code);
-        written.push(path.relative(ctx.cwd, file));
-      }
-      output(ctx, { written }, (_d, u) => u.success(`Wrote ${written.join(', ')}`));
-    },
-  },
-  serve: {
-    summary: 'Watch local functions and redeploy on every save',
-    usage: 'motherbase functions serve [name]',
-    async run(ctx, args) {
-      // Deliberately not a second local runtime. The isolate, the secrets and
-      // the bundler all live in the project API, and a local re-implementation
-      // would differ from production in exactly the ways that matter. This
-      // watches and redeploys instead, so the edit-invoke loop is one save long.
-      const targets = resolveLocal(ctx, args[0]);
-      if (!targets.length) {
-        throw new CliError('Nothing to serve. Create a function with: motherbase functions new <name>');
-      }
-
-      for (const fn of targets) {
-        await deployOne(ctx, fn);
-        ui.success(`Deployed ${fn.name}`);
-        ui.info(`  POST ${api.projectUrl(ctx, `/edge/${fn.name}`)}`);
-      }
-      ui.info('Watching for changes. Ctrl-C to stop.');
-
-      const pending = new Map();
-      for (const fn of targets) {
-        fs.watch(fn.dir, { recursive: true }, () => {
-          // Editors save in bursts (write, rename, truncate). Coalescing them
-          // keeps one save from becoming three deploys.
-          clearTimeout(pending.get(fn.name));
-          pending.set(
-            fn.name,
-            setTimeout(async () => {
-              try {
-                await deployOne(ctx, fn);
-                ui.success(`Redeployed ${fn.name} at ${new Date().toLocaleTimeString()}`);
-              } catch (error) {
-                ui.warn(`${fn.name}: ${error.message}`);
-              }
-            }, 150),
-          );
-        });
-      }
-
-      // Hold the process open; the watchers are the work.
-      await new Promise(() => {});
-    },
-  },
-  delete: {
-    summary: 'Delete an edge function by id',
-    usage: 'motherbase functions delete <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'DELETE', `/edge-functions/${id}`);
-      output(ctx, data, (d, u) => u.success(`Deleted function ${id}`));
-    },
-  },
-  invoke: {
-    summary: 'Invoke an edge function by route',
-    usage: 'motherbase functions invoke <route> [--body <json>]',
-    async run(ctx, args, flags) {
-      const route = requireArg(args[0], 'route');
-      let body = {};
-      if (flags.body) {
-        try { body = JSON.parse(flags.body); } catch { throw new CliError('--body must be valid JSON'); }
-      }
-      const data = await api.edgeInvokeRequest(ctx, route, body);
-      output(ctx, data, (d, u) => u.json(d));
-    },
-  },
-  logs: {
-    summary: 'Show logs for an edge function',
-    usage: 'motherbase functions logs <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'GET', `/edge-functions/${id}/logs`);
-      output(ctx, data, (d, u) => {
-        const logs = (d && d.logs) || d || [];
-        if (Array.isArray(logs)) logs.forEach(l => u.print(typeof l === 'string' ? l : JSON.stringify(l)));
-        else u.json(d);
-      });
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Edge functions (repo files, deploy, invoke, logs)',
-  usage: 'motherbase functions <list|get|new|deploy|pull|serve|delete|invoke|logs> ...',
-  subcommands,
-};
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const api = require('../api');
+const ui = require('../ui');
+const { output, alias, requireArg } = require('./_util');
+const { CliError } = require('../context');
+const { templates, DEFAULT_TEMPLATE, findTemplate, renderTemplate } = require('../edge-templates');
+
+// Functions live as repo files, one directory per function, the layout Supabase
+// projects already use:
+//
+//   functions/
+//     stripe-webhook/
+//       index.ts
+//
+// The directory name is both the function name and its route, so deploying is
+// `motherbase functions deploy` with nothing to remember.
+const DEFAULT_DIR = 'functions';
+const LEGACY_DIR = path.join('motherbase', 'functions');
+const ENTRY_NAMES = ['index.ts', 'index.js', 'index.mjs'];
+
+// Written next to the functions so an editor knows the runtime globals the
+// Deno edge runtime injects. Without it every `env.X` / `sendMail(...)` is a red squiggle.
+const TYPES_FILE = 'motherbase.d.ts';
+const TYPES = `// Generated by \`motherbase functions new\`. Runtime globals injected by the
+// Motherbase edge runtime. Safe to re-generate: delete it and scaffold again.
+
+/** This project's edge secrets (Studio > Edge functions > Secrets). */
+declare const env: Record<string, string>;
+
+/** The invoke payload, for the legacy expression-shaped function form. */
+declare const context: Record<string, unknown>;
+
+/**
+ * Sends an email through this project's SMTP settings, the same transport the
+ * auth emails use: the project API sends it, so there is no mail API to sign up for.
+ * Rejects when SMTP is unconfigured, when \`to\` is not an address, or when
+ * neither \`text\` nor \`html\` is given.
+ */
+declare function sendMail(options: {
+  to: string;
+  subject: string;
+  text?: string;
+  html?: string;
+}): Promise<{ ok: true }>;
+`;
+
+function functionsDir(ctx) {
+  for (const candidate of [DEFAULT_DIR, LEGACY_DIR]) {
+    if (fs.existsSync(path.join(ctx.cwd, candidate))) return path.join(ctx.cwd, candidate);
+  }
+  return path.join(ctx.cwd, DEFAULT_DIR);
+}
+
+/** Entry file of a function directory, or null when it has none. */
+function entryFile(dir) {
+  for (const name of ENTRY_NAMES) {
+    const file = path.join(dir, name);
+    if (fs.existsSync(file)) return file;
+  }
+  return null;
+}
+
+/** Every locally defined function: `{ name, dir, entry }`. */
+function localFunctions(ctx) {
+  const root = functionsDir(ctx);
+  if (!fs.existsSync(root)) return [];
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter(item => item.isDirectory())
+    .map(item => ({ name: item.name, dir: path.join(root, item.name), entry: entryFile(path.join(root, item.name)) }))
+    .filter(fn => fn.entry);
+}
+
+function resolveLocal(ctx, name) {
+  const all = localFunctions(ctx);
+  if (!name) return all;
+  const hit = all.find(fn => fn.name === name);
+  if (!hit) {
+    const expected = path.relative(ctx.cwd, path.join(functionsDir(ctx), name, 'index.ts'));
+    throw new CliError(`No local function "${name}". Expected ${expected}.`);
+  }
+  return [hit];
+}
+
+/** Upsert by route, so deploying twice updates instead of conflicting. */
+async function upsertFunction(ctx, body) {
+  const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
+  const existing = ((listing && listing.functions) || []).find(f => f.route === body.route);
+  if (existing) return api.adminRequest(ctx, 'PATCH', `/edge-functions/${existing.id}`, { body });
+  return api.adminRequest(ctx, 'POST', '/edge-functions', { body: { ...body, enabled: true } });
+}
+
+async function deployOne(ctx, fn, flags) {
+  const code = fs.readFileSync(fn.entry, 'utf8');
+  const body = { name: fn.name, route: fn.name, code };
+  if (flags && flags.memory) body.memoryLimitMb = Number(flags.memory);
+  if (flags && flags.timeout) body.timeoutMs = Number(flags.timeout);
+  return upsertFunction(ctx, body);
+}
+
+const subcommands = {
+  list: {
+    summary: 'List edge functions',
+    usage: 'motherbase functions list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/edge-functions');
+      const rows = (data && data.functions) || [];
+      output(ctx, data, (_d, u) =>
+        u.table(rows, [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'route', label: 'ROUTE' },
+          { key: 'enabled', label: 'ENABLED' },
+        ]),
+      );
+    },
+  },
+  get: {
+    summary: 'Get an edge function by id',
+    usage: 'motherbase functions get <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/edge-functions/${id}`);
+      output(ctx, data, (d, u) => u.keyValue((d && d.function) || d || {}));
+    },
+  },
+  new: {
+    summary: 'Scaffold functions/<name>/index.ts',
+    usage: `motherbase functions new <name> [--template ${templates.map(t => t.id).join('|')}]`,
+    async run(ctx, args, flags) {
+      const name = requireArg(args[0], 'name');
+      const template = findTemplate(flags.template || DEFAULT_TEMPLATE);
+      if (!template) {
+        throw new CliError(`Unknown template "${flags.template}". Use one of: ${templates.map(t => t.id).join(', ')}.`);
+      }
+      if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) {
+        throw new CliError('Function names are lowercase letters, digits and hyphens (the name is also the route).');
+      }
+      const dir = path.join(functionsDir(ctx), name);
+      if (entryFile(dir)) throw new CliError(`${path.relative(ctx.cwd, dir)} already has an entry file.`);
+      fs.mkdirSync(dir, { recursive: true });
+      const file = path.join(dir, 'index.ts');
+      fs.writeFileSync(file, renderTemplate(template, name));
+      ui.success(`Created ${path.relative(ctx.cwd, file)}`);
+      const types = path.join(functionsDir(ctx), TYPES_FILE);
+      if (!fs.existsSync(types)) {
+        fs.writeFileSync(types, TYPES);
+        ui.success(`Created ${path.relative(ctx.cwd, types)}`);
+      }
+      ui.info(`Deploy it with: motherbase functions deploy ${name}`);
+    },
+  },
+  deploy: {
+    summary: 'Deploy local functions (all of them, or one by name)',
+    usage: 'motherbase functions deploy [name] [--memory <mb>] [--timeout <ms>] [--file <f> --route <r>]',
+    async run(ctx, args, flags) {
+      // The single-file form predates the directory layout and stays supported:
+      // scripts and older docs pass --file.
+      if (flags.file) {
+        const route = flags.route || args[0];
+        if (!route) throw new CliError('--route is required with --file');
+        const code = fs.readFileSync(path.resolve(ctx.cwd, flags.file), 'utf8');
+        const name = flags.name || route;
+        const data = await upsertFunction(ctx, { name, route, code });
+        return output(ctx, data, (_d, u) => u.success(`Deployed function ${name} (${route})`));
+      }
+
+      const targets = resolveLocal(ctx, args[0]);
+      if (!targets.length) {
+        const where = path.relative(ctx.cwd, functionsDir(ctx));
+        throw new CliError(`No functions in ${where}. Create one with: motherbase functions new <name>`);
+      }
+
+      const deployed = [];
+      for (const fn of targets) {
+        await deployOne(ctx, fn, flags);
+        deployed.push(fn.name);
+      }
+      output(ctx, { deployed }, (_d, u) => u.success(`Deployed ${deployed.join(', ')}`));
+    },
+  },
+  pull: {
+    summary: 'Write deployed function source back to disk',
+    usage: 'motherbase functions pull [name]',
+    async run(ctx, args) {
+      const listing = await api.adminRequest(ctx, 'GET', '/edge-functions');
+      const all = (listing && listing.functions) || [];
+      const wanted = args[0] ? all.filter(f => f.route === args[0] || f.name === args[0]) : all;
+      if (!wanted.length) throw new CliError(args[0] ? `No deployed function "${args[0]}"` : 'No deployed functions');
+
+      const written = [];
+      for (const fn of wanted) {
+        // The list endpoint may omit code, so read the function itself.
+        const detail = await api.adminRequest(ctx, 'GET', `/edge-functions/${fn.id}`);
+        const code = (detail && detail.function ? detail.function.code : detail && detail.code) || '';
+        const dir = path.join(functionsDir(ctx), fn.route || fn.name);
+        fs.mkdirSync(dir, { recursive: true });
+        const file = path.join(dir, 'index.ts');
+        fs.writeFileSync(file, code);
+        written.push(path.relative(ctx.cwd, file));
+      }
+      output(ctx, { written }, (_d, u) => u.success(`Wrote ${written.join(', ')}`));
+    },
+  },
+  serve: {
+    summary: 'Watch local functions and redeploy on every save',
+    usage: 'motherbase functions serve [name]',
+    async run(ctx, args) {
+      // Deliberately not a second local runtime. The runtime, the secrets and
+      // the mail bridge all live with the project API, and a local re-implementation
+      // would differ from production in exactly the ways that matter. This
+      // watches and redeploys instead, so the edit-invoke loop is one save long.
+      const targets = resolveLocal(ctx, args[0]);
+      if (!targets.length) {
+        throw new CliError('Nothing to serve. Create a function with: motherbase functions new <name>');
+      }
+
+      for (const fn of targets) {
+        await deployOne(ctx, fn);
+        ui.success(`Deployed ${fn.name}`);
+        ui.info(`  POST ${api.projectUrl(ctx, `/edge/${fn.name}`)}`);
+      }
+      ui.info('Watching for changes. Ctrl-C to stop.');
+
+      const pending = new Map();
+      for (const fn of targets) {
+        fs.watch(fn.dir, { recursive: true }, () => {
+          // Editors save in bursts (write, rename, truncate). Coalescing them
+          // keeps one save from becoming three deploys.
+          clearTimeout(pending.get(fn.name));
+          pending.set(
+            fn.name,
+            setTimeout(async () => {
+              try {
+                await deployOne(ctx, fn);
+                ui.success(`Redeployed ${fn.name} at ${new Date().toLocaleTimeString()}`);
+              } catch (error) {
+                ui.warn(`${fn.name}: ${error.message}`);
+              }
+            }, 150),
+          );
+        });
+      }
+
+      // Hold the process open; the watchers are the work.
+      await new Promise(() => {});
+    },
+  },
+  delete: {
+    summary: 'Delete an edge function by id',
+    usage: 'motherbase functions delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/edge-functions/${id}`);
+      output(ctx, data, (d, u) => u.success(`Deleted function ${id}`));
+    },
+  },
+  invoke: {
+    summary: 'Invoke an edge function by route',
+    usage: 'motherbase functions invoke <route> [--body <json>]',
+    async run(ctx, args, flags) {
+      const route = requireArg(args[0], 'route');
+      let body = {};
+      if (flags.body) {
+        try { body = JSON.parse(flags.body); } catch { throw new CliError('--body must be valid JSON'); }
+      }
+      const data = await api.edgeInvokeRequest(ctx, route, body);
+      output(ctx, data, (d, u) => u.json(d));
+    },
+  },
+  logs: {
+    summary: 'Show logs for an edge function',
+    usage: 'motherbase functions logs <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/edge-functions/${id}/logs`);
+      output(ctx, data, (d, u) => {
+        const logs = (d && d.logs) || d || [];
+        if (Array.isArray(logs)) logs.forEach(l => u.print(typeof l === 'string' ? l : JSON.stringify(l)));
+        else u.json(d);
+      });
+    },
+  },
+};
+
+// Supabase's name for `pull`.
+subcommands.download = alias(subcommands.pull, 'motherbase functions download [name]');
+
+module.exports = {
+  summary: 'Edge functions (repo files, deploy, invoke, logs)',
+  usage: 'motherbase functions <list|get|new|deploy|pull|download|serve|delete|invoke|logs> ...',
+  subcommands,
+  upsertFunction,
+};