@motherbase/cli 0.2.6 → 0.2.8

package/src/commands/vault.js

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

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