@motherbase/cli 0.2.6 → 0.2.9

package/src/migration/commands.js

@@ -8,7 +8,7 @@
 //
 // Registered from commands/migration.js, commands/db.js and commands/test.js.
 // Files are read and written here (see ./files.js for the layout); the server
-// side is /api/admin/db (apps/server controllers/admin-db.controller.ts).
+// side is /api/admin/db (apps/server controllers/admin/admin-db.controller.ts).
 
 const fs = require('fs');
 const path = require('path');
@@ -81,7 +81,7 @@ function writeMigration(ctx, name, sql) {
   const version = files.versionAt();
   const file = path.join(ctx.cwd, files.MIGRATIONS_DIR, files.fileNameFor(version, name));
   fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, files.renderFile(sql));
+  fs.writeFileSync(file, files.renderFile(sql), { flag: 'wx' });
   return { version, name, file: path.relative(ctx.cwd, file) };
 }
 

package/src/migration/files.js

@@ -53,6 +53,16 @@ function byVersion(a, b) {
   return a.version < b.version ? -1 : a.version > b.version ? 1 : 0;
 }
 
+function assertUniqueVersions(migrations) {
+  const seen = new Map();
+  for (const migration of migrations) {
+    if (seen.has(migration.version)) {
+      throw new CliError(`Duplicate migration version ${migration.version}: ${seen.get(migration.version)} and ${migration.name}. Give each migration a unique version before continuing.`);
+    }
+    seen.set(migration.version, migration.name);
+  }
+}
+
 // ── File contents ────────────────────────────────────────────────────────────
 
 /** Split a file into up and down SQL at the `-- @down` marker. */
@@ -89,6 +99,7 @@ function readLocalMigrations(cwd) {
     const file = path.join(dir, fileName);
     migrations.push({ ...parsed, file, ...splitDown(fs.readFileSync(file, 'utf8')) });
   }
+  assertUniqueVersions(migrations);
   return { migrations: migrations.sort(byVersion), skipped };
 }
 
@@ -160,6 +171,7 @@ function readTests(cwd, only = []) {
  * as "on the remote", a rolled-back one is history, not schema.
  */
 function reconcile(local, remote) {
+  assertUniqueVersions(local);
   const rows = new Map();
   for (const file of local) rows.set(file.version, { version: file.version, name: file.name, local: file, remote: null });
   for (const entry of remote) {
@@ -207,6 +219,7 @@ function planPush(rows, { includeAll = false } = {}) {
  * reverse. A partial down would roll back a fraction of the squash.
  */
 function squash(migrations) {
+  assertUniqueVersions(migrations);
   if (migrations.length < 2) throw new CliError('Nothing to squash: need at least two migrations.');
   const ordered = [...migrations].sort(byVersion);
   const last = ordered[ordered.length - 1];

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

@@ -1,62 +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 };
+'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 };