@motherbase/cli 0.2.4 → 0.2.6

package/src/prompt.js

@@ -1,91 +1,91 @@
-'use strict';
-
-// readline-based prompting, including hidden password entry. Built-ins only.
-
-const readline = require('readline');
-
-function question(query) {
-  return new Promise(resolve => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(query, answer => {
-      rl.close();
-      resolve(answer.trim());
-    });
-  });
-}
-
-// Hidden input. Reads the TTY in raw mode so nothing echoes, masking each typed
-// character with '*'. Handles backspace, Enter, Ctrl+C, Ctrl+D and swallows
-// escape sequences (arrow keys etc.) so they never land in the value. When
-// stdin is not a TTY (pipes, CI) we fall back to a plain, unmasked line read.
-function password(query = 'Password: ') {
-  const stdin = process.stdin;
-  const stdout = process.stdout;
-  if (!stdin.isTTY) return question(query);
-
-  return new Promise(resolve => {
-    let value = '';
-    let inEscape = false;
-    stdout.write(query);
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.setEncoding('utf8');
-
-    const done = result => {
-      stdin.removeListener('data', onData);
-      stdin.setRawMode(false);
-      stdin.pause();
-      stdout.write('\n');
-      resolve(result);
-    };
-
-    const onData = chunk => {
-      for (const ch of chunk) {
-        if (inEscape) {
-          // Terminators of a CSI/escape sequence (e.g. arrow keys): stop swallowing.
-          if (/[a-zA-Z~]/.test(ch)) inEscape = false;
-          continue;
-        }
-        switch (ch) {
-          case '\r':
-          case '\n':
-          case '\u0004': // Ctrl-D
-            return done(value);
-          case '\u0003': // Ctrl-C
-            stdin.setRawMode(false);
-            stdin.pause();
-            stdout.write('\n');
-            process.exit(130);
-            return;
-          case '\u007f': // Backspace / Delete
-          case '\b':
-            if (value.length > 0) {
-              value = value.slice(0, -1);
-              stdout.write('\b \b');
-            }
-            break;
-          case '\u001b': // ESC — start of an escape sequence
-            inEscape = true;
-            break;
-          default:
-            // Ignore remaining control characters; mask printable ones.
-            if (ch >= ' ') {
-              value += ch;
-              stdout.write('*');
-            }
-        }
-      }
-    };
-
-    stdin.on('data', onData);
-  });
-}
-
-async function confirm(query, defaultYes = false) {
-  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
-  const answer = (await question(query + suffix)).toLowerCase();
-  if (!answer) return defaultYes;
-  return answer === 'y' || answer === 'yes';
-}
-
-module.exports = { question, password, confirm };
+'use strict';
+
+// readline-based prompting, including hidden password entry. Built-ins only.
+
+const readline = require('readline');
+
+function question(query) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(query, answer => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+// Hidden input. Reads the TTY in raw mode so nothing echoes, masking each typed
+// character with '*'. Handles backspace, Enter, Ctrl+C, Ctrl+D and swallows
+// escape sequences (arrow keys etc.) so they never land in the value. When
+// stdin is not a TTY (pipes, CI) we fall back to a plain, unmasked line read.
+function password(query = 'Password: ') {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  if (!stdin.isTTY) return question(query);
+
+  return new Promise(resolve => {
+    let value = '';
+    let inEscape = false;
+    stdout.write(query);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf8');
+
+    const done = result => {
+      stdin.removeListener('data', onData);
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdout.write('\n');
+      resolve(result);
+    };
+
+    const onData = chunk => {
+      for (const ch of chunk) {
+        if (inEscape) {
+          // Terminators of a CSI/escape sequence (e.g. arrow keys): stop swallowing.
+          if (/[a-zA-Z~]/.test(ch)) inEscape = false;
+          continue;
+        }
+        switch (ch) {
+          case '\r':
+          case '\n':
+          case '\u0004': // Ctrl-D
+            return done(value);
+          case '\u0003': // Ctrl-C
+            stdin.setRawMode(false);
+            stdin.pause();
+            stdout.write('\n');
+            process.exit(130);
+            return;
+          case '\u007f': // Backspace / Delete
+          case '\b':
+            if (value.length > 0) {
+              value = value.slice(0, -1);
+              stdout.write('\b \b');
+            }
+            break;
+          case '\u001b': // ESC: start of an escape sequence
+            inEscape = true;
+            break;
+          default:
+            // Ignore remaining control characters; mask printable ones.
+            if (ch >= ' ') {
+              value += ch;
+              stdout.write('*');
+            }
+        }
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+async function confirm(query, defaultYes = false) {
+  const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
+  const answer = (await question(query + suffix)).toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === 'y' || answer === 'yes';
+}
+
+module.exports = { question, password, confirm };

package/src/storage/remote.js

@@ -0,0 +1,62 @@
+'use strict';
+
+// Storage paths in the Supabase CLI's form: `ss:///<bucket>/<key>`. Anything
+// else is a local path. Kept free of I/O so the path rules can be tested alone.
+
+const path = require('path');
+const { CliError } = require('../context');
+
+const SCHEME = 'ss:///';
+
+const isRemote = value => typeof value === 'string' && value.startsWith('ss://');
+
+/** `ss:///bucket/a/b` → `{ bucket: 'bucket', key: 'a/b' }`; `ss:///` → `{ bucket: '', key: '' }`. */
+function parseRemote(value) {
+  if (!value.startsWith(SCHEME)) {
+    throw new CliError(`Storage paths look like ${SCHEME}<bucket>/<key>, got "${value}".`);
+  }
+  const [bucket = '', ...rest] = value.slice(SCHEME.length).split('/');
+  return { bucket, key: rest.join('/') };
+}
+
+function requireBucket(remote, value) {
+  if (!remote.bucket) throw new CliError(`"${value}" names no bucket.`);
+  return remote;
+}
+
+/** A key as a URL path: every segment encoded, the slashes between them kept. */
+const encodeKey = key => key.split('/').map(encodeURIComponent).join('/');
+
+/** `a/b/` and `a/b` both mean the prefix `a/b/`; the empty prefix is the bucket root. */
+const asPrefix = key => (key ? key.replace(/\/*$/, '/') : '');
+
+/**
+ * One directory level of a listing, as `ls` shows it: the objects directly
+ * under `prefix`, and each deeper key collapsed into its first folder (with a
+ * trailing slash), deduplicated, in order.
+ */
+function childrenOf(keys, prefix) {
+  const seen = new Set();
+  for (const key of keys) {
+    if (!key.startsWith(prefix)) continue;
+    const rest = key.slice(prefix.length);
+    const slash = rest.indexOf('/');
+    seen.add(slash < 0 ? rest : rest.slice(0, slash + 1));
+  }
+  return [...seen].filter(Boolean);
+}
+
+/**
+ * Where a single file lands. A destination ending in `/` (or the bucket root)
+ * is a folder, so the source's basename is appended, as `cp` does locally.
+ */
+function destinationKey(dstKey, sourceName) {
+  return !dstKey || dstKey.endsWith('/') ? `${dstKey}${path.basename(sourceName)}` : dstKey;
+}
+
+/** The key under `toPrefix` that `key` maps to when moving/copying `fromPrefix`. */
+function rebase(key, fromPrefix, toPrefix) {
+  return `${toPrefix}${key.slice(fromPrefix.length)}`;
+}
+
+module.exports = { SCHEME, isRemote, parseRemote, requireBucket, encodeKey, asPrefix, childrenOf, destinationKey, rebase };

package/src/ui.js

@@ -1,111 +1,111 @@
-'use strict';
-
-// Minimal, dependency-free presentation helpers: ANSI colour (auto-off when not a
-// TTY or NO_COLOR is set), a table printer, a key/value printer, a spinner, and a
-// --json passthrough.
-
-const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
-
-function wrap(code) {
-  return s => (useColor ? `[${code}m${s}` : String(s));
-}
-
-const color = {
-  bold: wrap('1'),
-  dim: wrap('2'),
-  red: wrap('31'),
-  green: wrap('32'),
-  yellow: wrap('33'),
-  cyan: wrap('36'),
-  gray: wrap('90'),
-};
-
-function print(msg = '') {
-  process.stdout.write(msg + '\n');
-}
-
-function printErr(msg = '') {
-  process.stderr.write(msg + '\n');
-}
-
-function success(msg) {
-  print(color.green('✓ ') + msg);
-}
-
-function info(msg) {
-  print(color.cyan('• ') + msg);
-}
-
-function warn(msg) {
-  printErr(color.yellow('! ') + msg);
-}
-
-function json(value) {
-  print(JSON.stringify(value, null, 2));
-}
-
-// Render an array of flat objects as an aligned table using the given columns
-// (array of keys or { key, label } specs). Falls back to a friendly note if empty.
-function table(rows, columns) {
-  if (!Array.isArray(rows) || rows.length === 0) {
-    print(color.dim('(no rows)'));
-    return;
-  }
-  const cols = (columns || Object.keys(rows[0])).map(c =>
-    typeof c === 'string' ? { key: c, label: c } : c,
-  );
-  const widths = cols.map(c => c.label.length);
-  const cells = rows.map(row =>
-    cols.map((c, i) => {
-      const v = row[c.key];
-      const s = v === undefined || v === null ? '' : String(v);
-      if (s.length > widths[i]) widths[i] = s.length;
-      return s;
-    }),
-  );
-  const header = cols.map((c, i) => color.bold(c.label.padEnd(widths[i]))).join('  ');
-  print(header);
-  print(color.dim(cols.map((_, i) => '-'.repeat(widths[i])).join('  ')));
-  for (const rowCells of cells) {
-    print(rowCells.map((s, i) => s.padEnd(widths[i])).join('  '));
-  }
-}
-
-// Print a { key: value } object as aligned "key : value" lines.
-function keyValue(obj) {
-  if (!obj || typeof obj !== 'object') {
-    print(String(obj));
-    return;
-  }
-  const keys = Object.keys(obj);
-  const w = keys.reduce((m, k) => Math.max(m, k.length), 0);
-  for (const k of keys) {
-    let v = obj[k];
-    if (v && typeof v === 'object') v = JSON.stringify(v);
-    print(`${color.gray(k.padEnd(w))}  ${v === undefined || v === null ? '' : v}`);
-  }
-}
-
-// A tiny spinner. No-op (single status line) when stderr is not a TTY.
-function spinner(text) {
-  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-  if (!process.stderr.isTTY) {
-    printErr(color.dim(text + ' ...'));
-    return { stop() {}, succeed() {}, fail() {} };
-  }
-  let i = 0;
-  const timer = setInterval(() => {
-    process.stderr.write(`\r${color.cyan(frames[i++ % frames.length])} ${text}`);
-  }, 80);
-  const clear = () => {
-    clearInterval(timer);
-    process.stderr.write('\r');
-  };
-  return {
-    stop: clear,
-    succeed(msg) { clear(); if (msg) printErr(color.green('✓ ') + msg); },
-    fail(msg) { clear(); if (msg) printErr(color.red('✗ ') + msg); },
-  };
-}
-
-module.exports = { color, print, printErr, success, info, warn, json, table, keyValue, spinner };
+'use strict';
+
+// Minimal, dependency-free presentation helpers: ANSI colour (auto-off when not a
+// TTY or NO_COLOR is set), a table printer, a key/value printer, a spinner, and a
+// --json passthrough.
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+
+function wrap(code) {
+  return s => (useColor ? `[${code}m${s}` : String(s));
+}
+
+const color = {
+  bold: wrap('1'),
+  dim: wrap('2'),
+  red: wrap('31'),
+  green: wrap('32'),
+  yellow: wrap('33'),
+  cyan: wrap('36'),
+  gray: wrap('90'),
+};
+
+function print(msg = '') {
+  process.stdout.write(msg + '\n');
+}
+
+function printErr(msg = '') {
+  process.stderr.write(msg + '\n');
+}
+
+function success(msg) {
+  print(color.green('✓ ') + msg);
+}
+
+function info(msg) {
+  print(color.cyan('• ') + msg);
+}
+
+function warn(msg) {
+  printErr(color.yellow('! ') + msg);
+}
+
+function json(value) {
+  print(JSON.stringify(value, null, 2));
+}
+
+// Render an array of flat objects as an aligned table using the given columns
+// (array of keys or { key, label } specs). Falls back to a friendly note if empty.
+function table(rows, columns) {
+  if (!Array.isArray(rows) || rows.length === 0) {
+    print(color.dim('(no rows)'));
+    return;
+  }
+  const cols = (columns || Object.keys(rows[0])).map(c =>
+    typeof c === 'string' ? { key: c, label: c } : c,
+  );
+  const widths = cols.map(c => c.label.length);
+  const cells = rows.map(row =>
+    cols.map((c, i) => {
+      const v = row[c.key];
+      const s = v === undefined || v === null ? '' : String(v);
+      if (s.length > widths[i]) widths[i] = s.length;
+      return s;
+    }),
+  );
+  const header = cols.map((c, i) => color.bold(c.label.padEnd(widths[i]))).join('  ');
+  print(header);
+  print(color.dim(cols.map((_, i) => '-'.repeat(widths[i])).join('  ')));
+  for (const rowCells of cells) {
+    print(rowCells.map((s, i) => s.padEnd(widths[i])).join('  '));
+  }
+}
+
+// Print a { key: value } object as aligned "key : value" lines.
+function keyValue(obj) {
+  if (!obj || typeof obj !== 'object') {
+    print(String(obj));
+    return;
+  }
+  const keys = Object.keys(obj);
+  const w = keys.reduce((m, k) => Math.max(m, k.length), 0);
+  for (const k of keys) {
+    let v = obj[k];
+    if (v && typeof v === 'object') v = JSON.stringify(v);
+    print(`${color.gray(k.padEnd(w))}  ${v === undefined || v === null ? '' : v}`);
+  }
+}
+
+// A tiny spinner. No-op (single status line) when stderr is not a TTY.
+function spinner(text) {
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  if (!process.stderr.isTTY) {
+    printErr(color.dim(text + ' ...'));
+    return { stop() {}, succeed() {}, fail() {} };
+  }
+  let i = 0;
+  const timer = setInterval(() => {
+    process.stderr.write(`\r${color.cyan(frames[i++ % frames.length])} ${text}`);
+  }, 80);
+  const clear = () => {
+    clearInterval(timer);
+    process.stderr.write('\r');
+  };
+  return {
+    stop: clear,
+    succeed(msg) { clear(); if (msg) printErr(color.green('✓ ') + msg); },
+    fail(msg) { clear(); if (msg) printErr(color.red('✗ ') + msg); },
+  };
+}
+
+module.exports = { color, print, printErr, success, info, warn, json, table, keyValue, spinner };

package/src/commands/migrations.js

@@ -1,85 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const api = require('../api');
-const { output, requireArg } = require('./_util');
-const { CliError } = require('../context');
-
-function readSql(cwd, file) {
-  if (!file) return undefined;
-  return fs.readFileSync(path.resolve(cwd, file), 'utf8');
-}
-
-const subcommands = {
-  list: {
-    summary: 'List schema migrations',
-    usage: 'motherbase migrations list',
-    async run(ctx) {
-      const data = await api.adminRequest(ctx, 'GET', '/migrations');
-      const rows = (data && data.migrations) || [];
-      output(ctx, data, (_d, ui) =>
-        ui.table(rows, [
-          { key: 'id', label: 'ID' },
-          { key: 'name', label: 'NAME' },
-          { key: 'status', label: 'STATUS' },
-          { key: 'appliedAt', label: 'APPLIED' },
-        ]),
-      );
-    },
-  },
-  diff: {
-    summary: 'Show a diff between live schema and migrations',
-    usage: 'motherbase migrations diff',
-    async run(ctx) {
-      const data = await api.adminRequest(ctx, 'GET', '/migrations/diff');
-      output(ctx, data, (d, ui) => ui.json(d));
-    },
-  },
-  get: {
-    summary: 'Show a single migration',
-    usage: 'motherbase migrations get <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'GET', `/migrations/${id}`);
-      output(ctx, data, (d, ui) => ui.keyValue((d && d.migration) || d || {}));
-    },
-  },
-  create: {
-    summary: 'Create a migration from up/down SQL files',
-    usage: 'motherbase migrations create --name <name> --up <file.sql> [--down <file.sql>]',
-    async run(ctx, args, flags) {
-      const name = flags.name || args[0];
-      if (!name) throw new CliError('--name is required');
-      const upSql = readSql(ctx.cwd, flags.up);
-      const downSql = readSql(ctx.cwd, flags.down);
-      if (!upSql) throw new CliError('--up <file.sql> is required');
-      const data = await api.adminRequest(ctx, 'POST', '/migrations', { body: { name, upSql, downSql } });
-      output(ctx, data, (d, ui) => ui.success(`Created migration ${name}`));
-    },
-  },
-  apply: {
-    summary: 'Apply a migration',
-    usage: 'motherbase migrations apply <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'POST', `/migrations/${id}/apply`);
-      output(ctx, data, (d, ui) => ui.success(`Applied ${id}`));
-    },
-  },
-  rollback: {
-    summary: 'Roll back a migration',
-    usage: 'motherbase migrations rollback <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'POST', `/migrations/${id}/rollback`);
-      output(ctx, data, (d, ui) => ui.success(`Rolled back ${id}`));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Schema migrations (list/diff/create/apply/rollback)',
-  usage: 'motherbase migrations <list|diff|get|create|apply|rollback> ...',
-  subcommands,
-};