instant-cli 1.0.33 → 1.0.34

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "instant-cli",
   "type": "module",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "description": "Instant's CLI",
   "license": "Apache-2.0",
   "homepage": "https://github.com/instantdb/instant/tree/main/client/packages/cli",
@@ -50,9 +50,9 @@
     "strip-ansi": "^7.1.2",
     "supports-hyperlinks": "^4.4.0",
     "unconfig": "^7.5.0",
-    "@instantdb/core": "1.0.33",
-    "@instantdb/version": "1.0.33",
-    "@instantdb/platform": "1.0.33"
+    "@instantdb/core": "1.0.34",
+    "@instantdb/platform": "1.0.34",
+    "@instantdb/version": "1.0.34"
   },
   "devDependencies": {
     "@babel/core": "^7.17.9",

package/src/commands/webhooks/add.ts

@@ -0,0 +1,111 @@
+import chalk from 'chalk';
+import { Effect } from 'effect';
+import type { WebhookAction } from '@instantdb/platform';
+import type { OptsFromCommand, webhooksAddDef } from '../../index.ts';
+import { Args } from '../../lib/args.ts';
+import { runUIEffect } from '../../lib/ui.ts';
+import { clearPromptTrail, UI } from '../../ui/index.ts';
+import {
+  getRemoteNamespaces,
+  parseActions,
+  parseNamespaces,
+  useWebhooksManager,
+  WEBHOOK_ACTIONS,
+} from '../../lib/webhooks.ts';
+import { BadArgsError } from '../../errors.ts';
+import { GlobalOpts } from '../../context/globalOpts.ts';
+import { logWebhookEvent, validateWebhookUrl } from './shared.ts';
+
+export const webhooksAddCmd = Effect.fn(
+  function* (opts: OptsFromCommand<typeof webhooksAddDef>) {
+    const { yes } = yield* GlobalOpts;
+
+    const url = yield* Args.text(opts, 'url').pipe(
+      Args.prompt({
+        prompt: 'Webhook URL:',
+        placeholder: 'https://...',
+        validate: validateWebhookUrl,
+        modifyOutput: UI.modifiers.piped([
+          UI.modifiers.topPadding,
+          UI.modifiers.dimOnComplete,
+        ]),
+      }),
+      Args.validate(validateWebhookUrl),
+      Args.required(),
+    );
+
+    let namespaces = yield* parseNamespaces(opts.namespaces);
+    if (!namespaces) {
+      if (yes) {
+        return yield* BadArgsError.make({
+          message:
+            'Missing required value for --namespaces (comma-separated list)',
+        });
+      }
+      const available = yield* getRemoteNamespaces;
+      if (available && available.length > 0) {
+        namespaces = yield* runUIEffect(
+          new UI.MultiSelect<string>({
+            options: available.map((name) => ({ value: name, label: name })),
+            promptText: 'Namespaces to listen to:',
+            minSelected: 1,
+            modifyOutput: UI.modifiers.dimOnComplete,
+          }),
+        );
+      } else {
+        const raw = yield* runUIEffect(
+          new UI.TextInput({
+            prompt: 'Namespaces (comma-separated):',
+            placeholder: 'posts,comments',
+            modifyOutput: UI.modifiers.piped([
+              UI.modifiers.topPadding,
+              UI.modifiers.dimOnComplete,
+            ]),
+          }),
+        );
+        namespaces = yield* parseNamespaces(raw);
+        if (!namespaces) {
+          return yield* BadArgsError.make({
+            message: '--namespaces must include at least one namespace',
+          });
+        }
+      }
+    }
+
+    let actions = yield* parseActions(opts.actions);
+    if (!actions) {
+      if (yes) {
+        return yield* BadArgsError.make({
+          message:
+            'Missing required value for --actions (comma-separated list of create,update,delete)',
+        });
+      }
+      actions = yield* runUIEffect(
+        new UI.MultiSelect<WebhookAction>({
+          options: WEBHOOK_ACTIONS.map((a) => ({ value: a, label: a })),
+          promptText: 'Actions to trigger on:',
+          minSelected: 1,
+          modifyOutput: UI.modifiers.dimOnComplete,
+        }),
+      );
+    }
+
+    const webhook = yield* useWebhooksManager(
+      (m) => m.create({ url, namespaces, actions }),
+      'Error creating webhook',
+    );
+
+    yield* Effect.sync(clearPromptTrail);
+    yield* logWebhookEvent('added', webhook);
+  },
+  Effect.catchTag('BadArgsError', (e) =>
+    Effect.gen(function* () {
+      yield* Effect.logError(e.message);
+      yield* Effect.log(
+        chalk.dim(
+          'hint: run `instant-cli webhook add --help` for available arguments',
+        ),
+      );
+    }),
+  ),
+);

package/src/commands/webhooks/delete.ts

@@ -0,0 +1,23 @@
+import { Effect } from 'effect';
+import type { OptsFromCommand, webhooksDeleteDef } from '../../index.ts';
+import { useWebhooksManager } from '../../lib/webhooks.ts';
+import { logWebhookEvent, resolveWebhookId } from './shared.ts';
+
+export const webhooksDeleteCmd = Effect.fn(function* (
+  opts: OptsFromCommand<typeof webhooksDeleteDef>,
+) {
+  const id = yield* resolveWebhookId({
+    id: opts.id,
+    picker: {
+      promptText: 'Select a webhook to delete:',
+      emptyMessage: 'No webhooks configured.',
+    },
+  });
+  if (!id) return;
+
+  const webhook = yield* useWebhooksManager(
+    (m) => m.delete(id),
+    'Error deleting webhook',
+  );
+  yield* logWebhookEvent('deleted', webhook);
+});

package/src/commands/webhooks/disable.ts

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+import type { OptsFromCommand, webhooksDisableDef } from '../../index.ts';
+import { useWebhooksManager } from '../../lib/webhooks.ts';
+import { logWebhookEvent, resolveWebhookId } from './shared.ts';
+
+export const webhooksDisableCmd = Effect.fn(function* (
+  opts: OptsFromCommand<typeof webhooksDisableDef>,
+) {
+  const id = yield* resolveWebhookId({
+    id: opts.id,
+    picker: {
+      promptText: 'Select a webhook to disable:',
+      emptyMessage: 'No active webhooks.',
+      filter: (w) => w.status === 'active',
+    },
+  });
+  if (!id) return;
+
+  const webhook = yield* useWebhooksManager(
+    (m) => m.disable(id, opts.reason ? { reason: opts.reason } : undefined),
+    'Error disabling webhook',
+  );
+  yield* logWebhookEvent('disabled', webhook);
+});

package/src/commands/webhooks/enable.ts

@@ -0,0 +1,24 @@
+import { Effect } from 'effect';
+import type { OptsFromCommand, webhooksEnableDef } from '../../index.ts';
+import { useWebhooksManager } from '../../lib/webhooks.ts';
+import { logWebhookEvent, resolveWebhookId } from './shared.ts';
+
+export const webhooksEnableCmd = Effect.fn(function* (
+  opts: OptsFromCommand<typeof webhooksEnableDef>,
+) {
+  const id = yield* resolveWebhookId({
+    id: opts.id,
+    picker: {
+      promptText: 'Select a webhook to enable:',
+      emptyMessage: 'No disabled webhooks.',
+      filter: (w) => w.status === 'disabled',
+    },
+  });
+  if (!id) return;
+
+  const webhook = yield* useWebhooksManager(
+    (m) => m.enable(id),
+    'Error enabling webhook',
+  );
+  yield* logWebhookEvent('enabled', webhook);
+});

package/src/commands/webhooks/events/list.ts

@@ -0,0 +1,38 @@
+import { Effect } from 'effect';
+import type { OptsFromCommand, webhooksEventsListDef } from '../../../index.ts';
+import { fetchRecentEvents } from '../../../lib/webhooks.ts';
+import { logEventDetail, resolveWebhookId } from '../shared.ts';
+
+const EVENT_LIMIT = 100;
+
+export const webhooksEventsListCmd = Effect.fn(function* (
+  opts: OptsFromCommand<typeof webhooksEventsListDef>,
+) {
+  const webhookId = yield* resolveWebhookId({
+    id: opts.webhookId,
+    flagName: '--webhook-id',
+    picker: {
+      promptText: 'Select a webhook to inspect:',
+      emptyMessage: 'No webhooks configured.',
+    },
+  });
+  if (!webhookId) return;
+
+  const events = yield* fetchRecentEvents(webhookId, EVENT_LIMIT);
+
+  if (opts.json) {
+    yield* Effect.log(JSON.stringify(events, null, 2));
+    return;
+  }
+
+  if (events.length === 0) {
+    yield* Effect.log('No events for this webhook.');
+    return;
+  }
+
+  for (const event of events) {
+    for (const line of logEventDetail(event)) {
+      yield* Effect.log(line);
+    }
+  }
+});

package/src/commands/webhooks/events/payload.ts

@@ -0,0 +1,56 @@
+import chalk from 'chalk';
+import { Effect } from 'effect';
+import type {
+  OptsFromCommand,
+  webhooksEventsPayloadDef,
+} from '../../../index.ts';
+import { GlobalOpts } from '../../../context/globalOpts.ts';
+import { BadArgsError } from '../../../errors.ts';
+import { useWebhooksManager } from '../../../lib/webhooks.ts';
+import { pickEvent, resolveWebhookId } from '../shared.ts';
+
+export const webhooksEventsPayloadCmd = Effect.fn(
+  function* (opts: OptsFromCommand<typeof webhooksEventsPayloadDef>) {
+    const { yes } = yield* GlobalOpts;
+
+    const webhookId = yield* resolveWebhookId({
+      id: opts.webhookId,
+      flagName: '--webhook-id',
+      picker: {
+        promptText: 'Select a webhook:',
+        emptyMessage: 'No webhooks configured.',
+      },
+    });
+    if (!webhookId) return;
+
+    let isn = opts.isn;
+    if (!isn) {
+      if (yes) {
+        return yield* BadArgsError.make({ message: 'Must specify --isn' });
+      }
+      const picked = yield* pickEvent({
+        webhookId,
+        promptText: 'Select an event:',
+        emptyMessage: 'No events for this webhook.',
+      });
+      if (!picked) return;
+      isn = picked.isn;
+    }
+
+    const payload = yield* useWebhooksManager(
+      (m) => m.getPayload(webhookId, isn!),
+      'Error fetching event payload',
+    );
+    yield* Effect.log(JSON.stringify(payload, null, 2));
+  },
+  Effect.catchTag('BadArgsError', (e) =>
+    Effect.gen(function* () {
+      yield* Effect.logError(e.message);
+      yield* Effect.log(
+        chalk.dim(
+          'hint: run `instant-cli webhook event payload --help` for available arguments',
+        ),
+      );
+    }),
+  ),
+);

package/src/commands/webhooks/events/resend.ts

@@ -0,0 +1,66 @@
+import chalk from 'chalk';
+import { Effect } from 'effect';
+import type {
+  OptsFromCommand,
+  webhooksEventsResendDef,
+} from '../../../index.ts';
+import { GlobalOpts } from '../../../context/globalOpts.ts';
+import { BadArgsError } from '../../../errors.ts';
+import { useWebhooksManager } from '../../../lib/webhooks.ts';
+import {
+  colorStatus,
+  logEventDetail,
+  pickEvent,
+  resolveWebhookId,
+} from '../shared.ts';
+
+export const webhooksEventsResendCmd = Effect.fn(
+  function* (opts: OptsFromCommand<typeof webhooksEventsResendDef>) {
+    const { yes } = yield* GlobalOpts;
+
+    const webhookId = yield* resolveWebhookId({
+      id: opts.webhookId,
+      flagName: '--webhook-id',
+      picker: {
+        promptText: 'Select a webhook:',
+        emptyMessage: 'No webhooks configured.',
+      },
+    });
+    if (!webhookId) return;
+
+    let isn = opts.isn;
+    if (!isn) {
+      if (yes) {
+        return yield* BadArgsError.make({ message: 'Must specify --isn' });
+      }
+      const picked = yield* pickEvent({
+        webhookId,
+        promptText: 'Select an event to resend:',
+        emptyMessage: 'No events for this webhook.',
+      });
+      if (!picked) return;
+      isn = picked.isn;
+    }
+
+    const event = yield* useWebhooksManager(
+      (m) => m.resendEvent(webhookId, isn!),
+      'Error resending event',
+    );
+
+    yield* Effect.log(`Resent event ${chalk.cyan(event.isn)}`);
+    yield* Effect.log(`Status: ${colorStatus(event.status)}`);
+    for (const line of logEventDetail(event).slice(1)) {
+      yield* Effect.log(line);
+    }
+  },
+  Effect.catchTag('BadArgsError', (e) =>
+    Effect.gen(function* () {
+      yield* Effect.logError(e.message);
+      yield* Effect.log(
+        chalk.dim(
+          'hint: run `instant-cli webhook event resend --help` for available arguments',
+        ),
+      );
+    }),
+  ),
+);

package/src/commands/webhooks/list.ts

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import { Effect } from 'effect';
+import type { WebhookInfo } from '@instantdb/platform';
+import type { OptsFromCommand, webhooksListDef } from '../../index.ts';
+import { useWebhooksManager } from '../../lib/webhooks.ts';
+import { joinActions, joinNamespaces } from './shared.ts';
+
+export const renderWebhook = (webhook: WebhookInfo) =>
+  Effect.gen(function* () {
+    yield* Effect.log(chalk.cyan(webhook.sink.url));
+    yield* Effect.log(`  ID: ${webhook.id}`);
+    yield* Effect.log(`  Status: ${webhook.status}`);
+    yield* Effect.log(`  Actions: ${joinActions(webhook.actions)}`);
+    yield* Effect.log(`  Namespaces: ${joinNamespaces(webhook.namespaces)}`);
+    if (webhook.disabledReason) {
+      yield* Effect.log(`  Disabled reason: ${webhook.disabledReason}`);
+    }
+  });
+
+export const webhooksListCmd = Effect.fn(function* (
+  opts: OptsFromCommand<typeof webhooksListDef>,
+) {
+  const webhooks = yield* useWebhooksManager(
+    (m) => m.list(),
+    'Error listing webhooks',
+  );
+
+  if (opts.json) {
+    yield* Effect.log(JSON.stringify(webhooks, null, 2));
+    return;
+  }
+
+  if (webhooks.length === 0) {
+    yield* Effect.log('No webhooks configured.');
+    return;
+  }
+
+  for (const webhook of webhooks) {
+    yield* renderWebhook(webhook);
+  }
+});