@motherbase/cli 0.2.4 → 0.2.6

package/src/commands/users.js

@@ -1,113 +1,142 @@
-'use strict';
-
-const api = require('../api');
-const { output, requireArg } = require('./_util');
-const { CliError } = require('../context');
-
-// Collect known user fields from flags into a body.
-function userBody(flags) {
-  const body = {};
-  for (const key of ['email', 'password', 'name', 'role']) {
-    if (flags[key] !== undefined) body[key] = flags[key];
-  }
-  return body;
-}
-
-const subcommands = {
-  list: {
-    summary: 'List project users',
-    usage: 'motherbase users list',
-    async run(ctx) {
-      const data = await api.adminRequest(ctx, 'GET', '/users');
-      const users = (data && data.users) || data || [];
-      output(ctx, data, (_d, ui) =>
-        ui.table(Array.isArray(users) ? users : [], [
-          { key: 'id', label: 'ID' },
-          { key: 'email', label: 'EMAIL' },
-          { key: 'role', label: 'ROLE' },
-        ]),
-      );
-    },
-  },
-  get: {
-    summary: 'Get a user by id',
-    usage: 'motherbase users get <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'GET', `/users/${id}`);
-      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
-    },
-  },
-  create: {
-    summary: 'Create a user',
-    usage: 'motherbase users create --email <e> --password <p> [--name <n>] [--role <r>]',
-    async run(ctx, args, flags) {
-      const body = userBody(flags);
-      if (!body.email || !body.password) throw new CliError('--email and --password are required');
-      const data = await api.adminRequest(ctx, 'POST', '/users', { body });
-      output(ctx, data, (d, ui) => ui.success(`Created user ${body.email}`));
-    },
-  },
-  update: {
-    summary: 'Update a user',
-    usage: 'motherbase users update <id> [--email ...] [--name ...] [--role ...]',
-    async run(ctx, args, flags) {
-      const id = requireArg(args[0], 'id');
-      const body = userBody(flags);
-      const data = await api.adminRequest(ctx, 'PATCH', `/users/${id}`, { body });
-      output(ctx, data, (d, ui) => ui.success(`Updated user ${id}`));
-    },
-  },
-  delete: {
-    summary: 'Delete a user',
-    usage: 'motherbase users delete <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'DELETE', `/users/${id}`);
-      output(ctx, data, (d, ui) => ui.success(`Deleted user ${id}`));
-    },
-  },
-  'reset-password': {
-    summary: 'Reset a user password',
-    usage: 'motherbase users reset-password <id> [--password <p>]',
-    async run(ctx, args, flags) {
-      const id = requireArg(args[0], 'id');
-      const body = flags.password ? { password: flags.password } : {};
-      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/reset-password`, { body });
-      output(ctx, data, (d, ui) => ui.success(`Password reset for ${id}`));
-    },
-  },
-  promote: {
-    summary: 'Promote a user to ADMIN',
-    usage: 'motherbase users promote <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/promote`);
-      output(ctx, data, (d, ui) => ui.success(`Promoted ${id}`));
-    },
-  },
-  demote: {
-    summary: 'Demote a user to USER',
-    usage: 'motherbase users demote <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/demote`);
-      output(ctx, data, (d, ui) => ui.success(`Demoted ${id}`));
-    },
-  },
-  'revoke-sessions': {
-    summary: 'Revoke all sessions for a user',
-    usage: 'motherbase users revoke-sessions <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/revoke-sessions`);
-      output(ctx, data, (d, ui) => ui.success(`Sessions revoked for ${id}`));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Project auth users',
-  usage: 'motherbase users <list|get|create|update|delete|reset-password|promote|demote|revoke-sessions> ...',
-  subcommands,
-};
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+// Collect known user fields from flags into a body.
+function userBody(flags) {
+  const body = {};
+  for (const key of ['email', 'password', 'name', 'role']) {
+    if (flags[key] !== undefined) body[key] = flags[key];
+  }
+  return body;
+}
+
+const subcommands = {
+  list: {
+    summary: 'List project users',
+    usage: 'motherbase users list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/users');
+      const users = (data && data.users) || data || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(Array.isArray(users) ? users : [], [
+          { key: 'id', label: 'ID' },
+          { key: 'email', label: 'EMAIL' },
+          { key: 'role', label: 'ROLE' },
+        ]),
+      );
+    },
+  },
+  get: {
+    summary: 'Get a user by id',
+    usage: 'motherbase users get <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/users/${id}`);
+      output(ctx, data, (d, ui) => ui.keyValue(d || {}));
+    },
+  },
+  create: {
+    summary: 'Create a user',
+    usage: 'motherbase users create --email <e> --password <p> [--name <n>] [--role <r>]',
+    async run(ctx, args, flags) {
+      const body = userBody(flags);
+      if (!body.email || !body.password) throw new CliError('--email and --password are required');
+      const data = await api.adminRequest(ctx, 'POST', '/users', { body });
+      output(ctx, data, (d, ui) => ui.success(`Created user ${body.email}`));
+    },
+  },
+  update: {
+    summary: 'Update a user',
+    usage: 'motherbase users update <id> [--email ...] [--name ...] [--role ...]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const body = userBody(flags);
+      const data = await api.adminRequest(ctx, 'PATCH', `/users/${id}`, { body });
+      output(ctx, data, (d, ui) => ui.success(`Updated user ${id}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a user',
+    usage: 'motherbase users delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/users/${id}`);
+      output(ctx, data, (d, ui) => ui.success(`Deleted user ${id}`));
+    },
+  },
+  'reset-password': {
+    summary: 'Reset a user password',
+    usage: 'motherbase users reset-password <id> [--password <p>]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const body = typeof flags.password === 'string' ? { password: flags.password } : {};
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/reset-password`, { body });
+      output(ctx, data, (d, ui) => ui.success(`Password reset for ${id}`));
+    },
+  },
+  promote: {
+    summary: 'Promote a user to ADMIN',
+    usage: 'motherbase users promote <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/promote`);
+      output(ctx, data, (d, ui) => ui.success(`Promoted ${id}`));
+    },
+  },
+  demote: {
+    summary: 'Demote a user to USER',
+    usage: 'motherbase users demote <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/demote`);
+      output(ctx, data, (d, ui) => ui.success(`Demoted ${id}`));
+    },
+  },
+  'revoke-sessions': {
+    summary: 'Revoke all sessions for a user',
+    usage: 'motherbase users revoke-sessions <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/users/${id}/revoke-sessions`);
+      output(ctx, data, (d, ui) => ui.success(`Sessions revoked for ${id}`));
+    },
+  },
+  audit: {
+    summary: 'Read the auth audit log, newest first',
+    usage: 'motherbase users audit [--action <a>] [--actor <email|id>] [--type <log type>] [--from <iso>] [--to <iso>] [--limit <n>]',
+    async run(ctx, args, flags) {
+      const query = {
+        action: flags.action,
+        actor: flags.actor,
+        log_type: flags.type,
+        from: flags.from,
+        to: flags.to,
+        per_page: flags.limit || 50,
+      };
+      const data = await api.adminRequest(ctx, 'GET', '/auth/audit-logs', { query });
+      const entries = ((data && data.entries) || []).map(e => ({
+        at: e.created_at,
+        action: e.payload.action,
+        actor: e.payload.actor_username || e.payload.actor_id,
+        ip: e.ip_address,
+      }));
+      output(ctx, data, (_d, ui) =>
+        ui.table(entries, [
+          { key: 'at', label: 'AT' },
+          { key: 'action', label: 'ACTION' },
+          { key: 'actor', label: 'ACTOR' },
+          { key: 'ip', label: 'IP' },
+        ]),
+      );
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Project auth users',
+  usage: 'motherbase users <list|get|create|update|delete|reset-password|promote|demote|revoke-sessions|audit> ...',
+  subcommands,
+};

package/src/commands/vault.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const subcommands = {
+  list: {
+    summary: 'List Vault secrets (names and metadata, never values)',
+    usage: 'motherbase vault list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/vault');
+      const secrets = (data && data.secrets) || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(secrets, [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'description', label: 'DESCRIPTION' },
+          { key: 'updatedAt', label: 'UPDATED' },
+        ]),
+      );
+    },
+  },
+  enable: {
+    summary: 'Install the Vault for this project',
+    usage: 'motherbase vault enable',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'POST', '/vault/enable');
+      output(ctx, data, (_d, ui) => ui.success('Vault enabled'));
+    },
+  },
+  create: {
+    summary: 'Store an encrypted secret',
+    usage: 'motherbase vault create <name> --secret <value> [--description <text>]',
+    async run(ctx, args, flags) {
+      const name = requireArg(args[0], 'name');
+      if (typeof flags.secret !== 'string') throw new CliError('--secret is required');
+      const body = { name, secret: flags.secret };
+      if (typeof flags.description === 'string') body.description = flags.description;
+      const data = await api.adminRequest(ctx, 'POST', '/vault/secrets', { body });
+      output(ctx, data, (_d, ui) => ui.success(`Created secret ${name}`));
+    },
+  },
+  update: {
+    summary: 'Rename a secret, change its value or its description',
+    usage: 'motherbase vault update <id> [--name <n>] [--secret <value>] [--description <text>]',
+    async run(ctx, args, flags) {
+      const id = requireArg(args[0], 'id');
+      const body = {};
+      for (const key of ['name', 'secret', 'description']) {
+        if (typeof flags[key] === 'string') body[key] = flags[key];
+      }
+      if (!Object.keys(body).length) throw new CliError('nothing to update: pass --name, --secret or --description');
+      const data = await api.adminRequest(ctx, 'PATCH', `/vault/secrets/${encodeURIComponent(id)}`, { body });
+      output(ctx, data, (_d, ui) => ui.success(`Updated secret ${id}`));
+    },
+  },
+  reveal: {
+    summary: 'Print the decrypted value of a secret',
+    usage: 'motherbase vault reveal <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'GET', `/vault/secrets/${encodeURIComponent(id)}/reveal`);
+      output(ctx, data, (d, ui) => ui.print(String((d && d.secret) ?? '')));
+    },
+  },
+  delete: {
+    summary: 'Delete a secret',
+    usage: 'motherbase vault delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/vault/secrets/${encodeURIComponent(id)}`);
+      output(ctx, data, (_d, ui) => ui.success(`Deleted secret ${id}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Encrypted secrets (Vault)',
+  usage: 'motherbase vault <list|enable|create|update|reveal|delete> ...',
+  subcommands,
+};

package/src/commands/webhooks.js

@@ -1,62 +1,62 @@
-'use strict';
-
-const api = require('../api');
-const { output, requireArg } = require('./_util');
-const { CliError } = require('../context');
-
-const subcommands = {
-  list: {
-    summary: 'List webhooks',
-    usage: 'motherbase webhooks list',
-    async run(ctx) {
-      const data = await api.adminRequest(ctx, 'GET', '/webhooks');
-      const rows = (data && data.webhooks) || data || [];
-      output(ctx, data, (_d, ui) =>
-        ui.table(Array.isArray(rows) ? rows : [], [
-          { key: 'id', label: 'ID' },
-          { key: 'name', label: 'NAME' },
-          { key: 'url', label: 'URL' },
-          { key: 'events', label: 'EVENTS' },
-        ]),
-      );
-    },
-  },
-  create: {
-    summary: 'Create a webhook',
-    usage: 'motherbase webhooks create --name <n> --url <u> --events a,b',
-    async run(ctx, args, flags) {
-      if (!flags.name || !flags.url || !flags.events) throw new CliError('--name, --url and --events are required');
-      const body = {
-        name: flags.name,
-        url: flags.url,
-        events: String(flags.events).split(',').map(s => s.trim()).filter(Boolean),
-      };
-      const data = await api.adminRequest(ctx, 'POST', '/webhooks', { body });
-      output(ctx, data, (d, ui) => ui.success(`Created webhook ${flags.name}`));
-    },
-  },
-  delete: {
-    summary: 'Delete a webhook',
-    usage: 'motherbase webhooks delete <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'DELETE', `/webhooks/${id}`);
-      output(ctx, data, (d, ui) => ui.success(`Deleted webhook ${id}`));
-    },
-  },
-  test: {
-    summary: 'Send a test event to a webhook',
-    usage: 'motherbase webhooks test <id>',
-    async run(ctx, args) {
-      const id = requireArg(args[0], 'id');
-      const data = await api.adminRequest(ctx, 'POST', `/webhooks/${id}/test`);
-      output(ctx, data, (d, ui) => ui.json(d));
-    },
-  },
-};
-
-module.exports = {
-  summary: 'Outgoing webhooks',
-  usage: 'motherbase webhooks <list|create|delete|test> ...',
-  subcommands,
-};
+'use strict';
+
+const api = require('../api');
+const { output, requireArg } = require('./_util');
+const { CliError } = require('../context');
+
+const subcommands = {
+  list: {
+    summary: 'List webhooks',
+    usage: 'motherbase webhooks list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/webhooks');
+      const rows = (data && data.webhooks) || data || [];
+      output(ctx, data, (_d, ui) =>
+        ui.table(Array.isArray(rows) ? rows : [], [
+          { key: 'id', label: 'ID' },
+          { key: 'name', label: 'NAME' },
+          { key: 'url', label: 'URL' },
+          { key: 'events', label: 'EVENTS' },
+        ]),
+      );
+    },
+  },
+  create: {
+    summary: 'Create a webhook',
+    usage: 'motherbase webhooks create --name <n> --url <u> --events a,b',
+    async run(ctx, args, flags) {
+      if (!flags.name || !flags.url || !flags.events) throw new CliError('--name, --url and --events are required');
+      const body = {
+        name: flags.name,
+        url: flags.url,
+        events: String(flags.events).split(',').map(s => s.trim()).filter(Boolean),
+      };
+      const data = await api.adminRequest(ctx, 'POST', '/webhooks', { body });
+      output(ctx, data, (d, ui) => ui.success(`Created webhook ${flags.name}`));
+    },
+  },
+  delete: {
+    summary: 'Delete a webhook',
+    usage: 'motherbase webhooks delete <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'DELETE', `/webhooks/${id}`);
+      output(ctx, data, (d, ui) => ui.success(`Deleted webhook ${id}`));
+    },
+  },
+  test: {
+    summary: 'Send a test event to a webhook',
+    usage: 'motherbase webhooks test <id>',
+    async run(ctx, args) {
+      const id = requireArg(args[0], 'id');
+      const data = await api.adminRequest(ctx, 'POST', `/webhooks/${id}/test`);
+      output(ctx, data, (d, ui) => ui.json(d));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Outgoing webhooks',
+  usage: 'motherbase webhooks <list|create|delete|test> ...',
+  subcommands,
+};

package/src/commands/whoami.js

@@ -1,20 +1,20 @@
-'use strict';
-
-const api = require('../api');
-const { output } = require('./_util');
-
-module.exports = {
-  summary: 'Show the current console, account and platform info',
-  usage: 'motherbase whoami',
-  async run(ctx) {
-    const { consoleUrl } = ctx.requireConsole();
-    const info = await api.consoleRequest(ctx, 'GET', '/info');
-    const data = {
-      console: consoleUrl,
-      email: ctx.accountEmail || null,
-      mode: info && info.mode,
-      domainSuffix: info && info.domainSuffix,
-    };
-    output(ctx, data, (d, ui) => ui.keyValue(d));
-  },
-};
+'use strict';
+
+const api = require('../api');
+const { output } = require('./_util');
+
+module.exports = {
+  summary: 'Show the current console, account and platform info',
+  usage: 'motherbase whoami',
+  async run(ctx) {
+    const { consoleUrl } = ctx.requireConsole();
+    const info = await api.consoleRequest(ctx, 'GET', '/info');
+    const data = {
+      console: consoleUrl,
+      email: ctx.accountEmail || null,
+      mode: info && info.mode,
+      domainSuffix: info && info.domainSuffix,
+    };
+    output(ctx, data, (d, ui) => ui.keyValue(d));
+  },
+};

package/src/commands/wrappers.js

@@ -0,0 +1,150 @@
+'use strict';
+
+const api = require('../api');
+const { output, requireArg, parseKeyValues } = require('./_util');
+const { CliError } = require('../context');
+
+const enc = encodeURIComponent;
+
+// `--option host=db.example.com --option port=5432`, repeatable.
+function options(flags) {
+  return parseKeyValues([].concat(flags.option || []), { coerce: false });
+}
+
+// `schema.name` -> [schema, name]
+function qualified(ref) {
+  const [schema, name, ...rest] = requireArg(ref, 'schema.table').split('.');
+  if (!schema || !name || rest.length) throw new CliError('expected <schema>.<table>');
+  return [schema, name];
+}
+
+// `--column id:integer --column label:text`, repeatable.
+function columns(flags) {
+  const specs = [].concat(flags.column || []);
+  if (!specs.length) throw new CliError('at least one --column <name>:<type> is required');
+  return specs.map(spec => {
+    const idx = String(spec).indexOf(':');
+    if (idx <= 0) throw new CliError(`expected <name>:<type>, got "${spec}"`);
+    return { name: spec.slice(0, idx), type: spec.slice(idx + 1) };
+  });
+}
+
+const subcommands = {
+  list: {
+    summary: 'List wrappers, foreign servers and foreign tables',
+    usage: 'motherbase wrappers list',
+    async run(ctx) {
+      const data = await api.adminRequest(ctx, 'GET', '/wrappers');
+      output(ctx, data, (d, ui) => {
+        ui.table((d && d.wrappers) || [], [
+          { key: 'name', label: 'WRAPPER' },
+          { key: 'available', label: 'AVAILABLE' },
+          { key: 'installed', label: 'INSTALLED' },
+        ]);
+        ui.table((d && d.servers) || [], [
+          { key: 'name', label: 'SERVER' },
+          { key: 'wrapper', label: 'WRAPPER' },
+          { key: 'remoteUser', label: 'REMOTE USER' },
+          { key: 'foreignTables', label: 'TABLES' },
+        ]);
+        ui.table((d && d.tables) || [], [
+          { key: 'schema', label: 'SCHEMA' },
+          { key: 'name', label: 'TABLE' },
+          { key: 'server', label: 'SERVER' },
+          { key: 'columns', label: 'COLUMNS' },
+        ]);
+      });
+    },
+  },
+  enable: {
+    summary: 'Install a wrapper extension',
+    usage: 'motherbase wrappers enable <postgres_fdw|file_fdw>',
+    async run(ctx, args) {
+      const wrapper = requireArg(args[0], 'wrapper');
+      const data = await api.adminRequest(ctx, 'POST', `/wrappers/${enc(wrapper)}/enable`);
+      output(ctx, data, (_d, ui) => ui.success(`Enabled ${wrapper}`));
+    },
+  },
+  'create-server': {
+    summary: 'Create a foreign server; the password goes to the Vault',
+    usage:
+      'motherbase wrappers create-server <name> --wrapper <postgres_fdw|file_fdw> [--option k=v ...] [--user <u> --password <p>]',
+    async run(ctx, args, flags) {
+      const name = requireArg(args[0], 'name');
+      const body = { name, wrapper: requireArg(flags.wrapper, '--wrapper'), options: options(flags) };
+      if (typeof flags.user === 'string') body.user = flags.user;
+      if (typeof flags.password === 'string') body.password = flags.password;
+      const data = await api.adminRequest(ctx, 'POST', '/wrappers/servers', { body });
+      output(ctx, data, (_d, ui) => ui.success(`Created foreign server ${name}`));
+    },
+  },
+  'drop-server': {
+    summary: 'Drop a foreign server',
+    usage: 'motherbase wrappers drop-server <name>',
+    async run(ctx, args) {
+      const name = requireArg(args[0], 'name');
+      const data = await api.adminRequest(ctx, 'DELETE', `/wrappers/servers/${enc(name)}`);
+      output(ctx, data, (_d, ui) => ui.success(`Dropped foreign server ${name}`));
+    },
+  },
+  credentials: {
+    summary: 'Replace the remote credentials of a foreign server',
+    usage: 'motherbase wrappers credentials <server> --user <u> --password <p>',
+    async run(ctx, args, flags) {
+      const name = requireArg(args[0], 'server');
+      if (typeof flags.user !== 'string' || typeof flags.password !== 'string') {
+        throw new CliError('--user and --password are required');
+      }
+      const body = { user: flags.user, password: flags.password };
+      const data = await api.adminRequest(ctx, 'PUT', `/wrappers/servers/${enc(name)}/credentials`, { body });
+      output(ctx, data, (_d, ui) => ui.success(`Updated credentials of ${name}`));
+    },
+  },
+  import: {
+    summary: 'Import a remote schema as foreign tables',
+    usage:
+      'motherbase wrappers import <server> --remote-schema <s> --local-schema <s> [--tables a,b]',
+    async run(ctx, args, flags) {
+      const name = requireArg(args[0], 'server');
+      const body = {
+        remoteSchema: requireArg(flags['remote-schema'], '--remote-schema'),
+        localSchema: requireArg(flags['local-schema'], '--local-schema'),
+      };
+      if (typeof flags.tables === 'string') body.tables = flags.tables.split(',').map(t => t.trim()).filter(Boolean);
+      const data = await api.adminRequest(ctx, 'POST', `/wrappers/servers/${enc(name)}/import`, { body });
+      output(ctx, data, (_d, ui) => ui.success(`Imported ${body.remoteSchema} into ${body.localSchema}`));
+    },
+  },
+  'create-table': {
+    summary: 'Create one foreign table',
+    usage:
+      'motherbase wrappers create-table <schema>.<table> --server <s> --column <name>:<type> ... [--option k=v ...]',
+    async run(ctx, args, flags) {
+      const [schema, name] = qualified(args[0]);
+      const body = {
+        server: requireArg(flags.server, '--server'),
+        schema,
+        name,
+        columns: columns(flags),
+        options: options(flags),
+      };
+      const data = await api.adminRequest(ctx, 'POST', '/wrappers/tables', { body });
+      output(ctx, data, (_d, ui) => ui.success(`Created foreign table ${schema}.${name}`));
+    },
+  },
+  'drop-table': {
+    summary: 'Drop a foreign table',
+    usage: 'motherbase wrappers drop-table <schema>.<table>',
+    async run(ctx, args) {
+      const [schema, name] = qualified(args[0]);
+      const data = await api.adminRequest(ctx, 'DELETE', `/wrappers/tables/${enc(schema)}/${enc(name)}`);
+      output(ctx, data, (_d, ui) => ui.success(`Dropped foreign table ${schema}.${name}`));
+    },
+  },
+};
+
+module.exports = {
+  summary: 'Foreign data wrappers (postgres_fdw, file_fdw)',
+  usage: 'motherbase wrappers <list|enable|create-server|drop-server|credentials|import|create-table|drop-table> ...',
+  subcommands,
+};