@amerged/ohmyhost-cli 0.1.44 → 0.1.45

package/dist/index.js

@@ -100,7 +100,7 @@ import {
   selectWorkspace,
   verifiedUserId,
   workspaceOf
-} from "./chunk-VJWPDFZ5.js";
+} from "./chunk-C6KEAOJP.js";
 import {
   CredentialStoreIntegrityError,
   CredentialStoreUnavailableError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amerged/ohmyhost-cli",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "type": "module",
   "engines": {
     "node": ">=22"

package/src/apps/product-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohmyhost/product-cli",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "private": true,
   "ohmyhost": {
     "deployment": "production",

package/src/apps/product-cli/src/cli.ts

@@ -419,8 +419,14 @@ const HELP_USAGE = Object.freeze({
     "ohmyhost database access list --project ULID [--environment dev|prod] --json",
   "database access revoke":
     "ohmyhost database access revoke --project ULID --access ULID --yes --json",
+  "database watch create":
+    "ohmyhost database watch create --project ULID --environment dev|prod --table NAME [--schema public] --columns COL[,COL] [--operations insert,update,delete] --idempotency-key KEY --yes --json (publishes only the listed columns, at most 32, of each row change as the event type data.<topic> printed in this answer; the table must exist as an ordinary table of the application; a sleeping database wakes; next, subscribe with 'ohmyhost database webhook create ... --event-types data.<topic>')",
+  "database watch list":
+    "ohmyhost database watch list --project ULID [--environment dev|prod] --json (dev when omitted; a sleeping database wakes)",
+  "database watch delete":
+    "ohmyhost database watch delete --project ULID --environment dev|prod --watch ID --idempotency-key KEY --yes --json",
   "database webhook create":
-    "ohmyhost database webhook create --project ULID --environment dev|prod --url HTTPS_URL --event-types TYPE[,TYPE] [--headers-file PATH] --idempotency-key KEY --yes --json (the signing secret is shown once in this answer; types: database.created, database.ready, database.woke, database.slept, database.suspended, database.resized, database.deleted; the headers file is a UTF-8 JSON object of at most 8 KiB)",
+    "ohmyhost database webhook create --project ULID --environment dev|prod --url HTTPS_URL --event-types TYPE[,TYPE] [--headers-file PATH] --idempotency-key KEY --yes --json (the signing secret is shown once in this answer; types: database.created, database.ready, database.woke, database.slept, database.suspended, database.resized, database.deleted, data.<topic> for the rows of one watched table printed by database watch create, or data.* for every watched table; a bare * is not accepted and does not include data events; the headers file is a UTF-8 JSON object of at most 8 KiB)",
   "database webhook list":
     "ohmyhost database webhook list --project ULID [--environment dev|prod] --json (dev when omitted; the secret is never listed)",
   "database webhook get":
@@ -1191,6 +1197,12 @@ export class ProductCli {
         return await this.listDatabaseAccess(command, signal);
       if (command.kind === "database-access-revoke")
         return await this.revokeDatabaseAccess(command, signal);
+      if (command.kind === "database-watch-create")
+        return await this.createDatabaseWatch(command, signal);
+      if (command.kind === "database-watch-list")
+        return await this.listDatabaseWatches(command, signal);
+      if (command.kind === "database-watch-delete")
+        return await this.deleteDatabaseWatch(command, signal);
       if (command.kind === "database-webhook-create")
         return await this.createDatabaseWebhook(command, signal);
       if (command.kind === "database-webhook-list")
@@ -1952,6 +1964,51 @@ export class ProductCli {
     return success("database access revoke", { status: "succeeded", access });
   }
 
+  /** The answer names the event type to subscribe to; the watch already carries the columns and the topic. */
+  private async createDatabaseWatch(
+    command: Extract<ProductCliCommand, { kind: "database-watch-create" }>,
+    signal: AbortSignal,
+  ): Promise<CliResult> {
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const watch = await api.createProjectDatabaseWatch({
+      projectId: command.projectId,
+      environment: command.environment,
+      idempotencyKey: command.idempotencyKey,
+      request: command.request,
+    });
+    return success("database watch create", {
+      status: "succeeded",
+      watch,
+      next_action: `Run '${this.dependencies.commandPrefix} database webhook create --project ${command.projectId} --environment ${command.environment} --url HTTPS_URL --event-types ${watch.event_type} --idempotency-key KEY --yes --json' to receive ${watch.event_type} events at an HTTPS receiver.`,
+    });
+  }
+
+  private async listDatabaseWatches(
+    command: Extract<ProductCliCommand, { kind: "database-watch-list" }>,
+    signal: AbortSignal,
+  ): Promise<CliResult> {
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const page = await api.listProjectDatabaseWatches({
+      projectId: command.projectId,
+      environment: command.environment,
+    });
+    return success("database watch list", { status: "succeeded", watch: page.items });
+  }
+
+  private async deleteDatabaseWatch(
+    command: Extract<ProductCliCommand, { kind: "database-watch-delete" }>,
+    signal: AbortSignal,
+  ): Promise<CliResult> {
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const deleted = await api.deleteProjectDatabaseWatch({
+      projectId: command.projectId,
+      environment: command.environment,
+      idempotencyKey: command.idempotencyKey,
+      watchId: command.watchId,
+    });
+    return success("database watch delete", { status: "succeeded", deleted });
+  }
+
   /** The signing secret is returned by create only; every other answer carries no secret. */
   private async createDatabaseWebhook(
     command: Extract<ProductCliCommand, { kind: "database-webhook-create" }>,
@@ -3526,6 +3583,9 @@ const parsedCommandName = (command: ProductCliCommand): CommandLabel => {
   if (command.kind === "database-access-list") return "database access list";
   if (command.kind === "database-access-revoke") return "database access revoke";
   if (command.kind === "database-psql") return "database psql";
+  if (command.kind === "database-watch-create") return "database watch create";
+  if (command.kind === "database-watch-list") return "database watch list";
+  if (command.kind === "database-watch-delete") return "database watch delete";
   if (command.kind === "database-webhook-create") return "database webhook create";
   if (command.kind === "database-webhook-list") return "database webhook list";
   if (command.kind === "database-webhook-get") return "database webhook get";

package/src/apps/product-cli/src/command.ts

@@ -6,9 +6,12 @@ import {
   parseDatabaseListLimit,
   parseDatabaseScheduleName,
   parseDatabaseUsageWindow,
+  parseDatabaseWatchCreateRequest,
+  parseDatabaseWatchId,
   parseDatabaseWebhookCreateRequest,
   parseDatabaseWebhookId,
-  type DatabaseWebhookEventType,
+  type DatabaseWatchRequest,
+  type DatabaseWebhookEventPattern,
 } from "@ohmyhost/contracts/database-events";
 import {
   databaseSizeForMemory,
@@ -404,12 +407,36 @@ export type ProductCliCommand =
       readonly yes: true;
       readonly credentialStore: "native";
     }
+  | {
+      readonly kind: "database-watch-create";
+      readonly projectId: string;
+      readonly environment: "dev" | "prod";
+      readonly request: DatabaseWatchRequest;
+      readonly idempotencyKey: string;
+      readonly yes: true;
+      readonly credentialStore: "native";
+    }
+  | {
+      readonly kind: "database-watch-list";
+      readonly projectId: string;
+      readonly environment: "dev" | "prod";
+      readonly credentialStore: "native";
+    }
+  | {
+      readonly kind: "database-watch-delete";
+      readonly projectId: string;
+      readonly environment: "dev" | "prod";
+      readonly watchId: string;
+      readonly idempotencyKey: string;
+      readonly yes: true;
+      readonly credentialStore: "native";
+    }
   | {
       readonly kind: "database-webhook-create";
       readonly projectId: string;
       readonly environment: "dev" | "prod";
       readonly url: string;
-      readonly eventTypes: readonly DatabaseWebhookEventType[];
+      readonly eventTypes: readonly DatabaseWebhookEventPattern[];
       readonly headersFile: string | null;
       readonly idempotencyKey: string;
       readonly yes: true;
@@ -1003,6 +1030,9 @@ export type RecognizedCommandLabel =
   | "database access create"
   | "database access list"
   | "database access revoke"
+  | "database watch create"
+  | "database watch list"
+  | "database watch delete"
   | "database webhook create"
   | "database webhook list"
   | "database webhook get"
@@ -1174,6 +1204,11 @@ export const recognizedCommandLabel = (argv: readonly string[]): RecognizedComma
       if (values[1] === "list") return "database access list";
       if (values[1] === "revoke") return "database access revoke";
     }
+    if (value === "database" && values[0] === "watch") {
+      if (values[1] === "create") return "database watch create";
+      if (values[1] === "list") return "database watch list";
+      if (values[1] === "delete") return "database watch delete";
+    }
     if (value === "database" && values[0] === "webhook") {
       if (values[1] === "create") return "database webhook create";
       if (values[1] === "list") return "database webhook list";
@@ -2063,6 +2098,92 @@ export const parseProductCliCommand = (argv: readonly string[]): ProductCliComma
     }
     throw new InvalidCommandError();
   }
+  if (first === "database" && values[0] === "watch") {
+    values.shift();
+    const subcommand = values.shift();
+    if (subcommand === "create") {
+      if (!yes || wait || follow || revoke || stdin) throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, [
+        "--project",
+        "--environment",
+        "--table",
+        "--schema",
+        "--columns",
+        "--operations",
+        "--idempotency-key",
+      ]);
+      const projectId = options["--project"],
+        environment = options["--environment"],
+        table = options["--table"],
+        schema = options["--schema"],
+        columns = options["--columns"],
+        operations = options["--operations"],
+        idempotencyKey = options["--idempotency-key"];
+      if (
+        !isValue(projectId) ||
+        !isValue(idempotencyKey) ||
+        !isValue(table) ||
+        !isValue(columns) ||
+        (environment !== "dev" && environment !== "prod")
+      )
+        throw new InvalidCommandError();
+      const request = contractValue(() =>
+        parseDatabaseWatchCreateRequest({
+          schema,
+          table,
+          columns: columns.split(","),
+          ...(operations === undefined ? {} : { operations: operations.split(",") }),
+        }),
+      );
+      return {
+        kind: "database-watch-create",
+        projectId,
+        environment,
+        request,
+        idempotencyKey,
+        yes: true,
+        credentialStore,
+      };
+    }
+    if (subcommand === "list") {
+      if (yes || wait || follow || revoke || stdin) throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, ["--project", "--environment"]);
+      const projectId = options["--project"],
+        environment = options["--environment"] ?? "dev";
+      if (!isValue(projectId) || (environment !== "dev" && environment !== "prod"))
+        throw new InvalidCommandError();
+      return { kind: "database-watch-list", projectId, environment, credentialStore };
+    }
+    if (subcommand === "delete") {
+      if (!yes || wait || follow || revoke || stdin) throw new InvalidCommandError();
+      const options = parseOptionalOptions(values, [
+        "--project",
+        "--environment",
+        "--watch",
+        "--idempotency-key",
+      ]);
+      const projectId = options["--project"],
+        environment = options["--environment"],
+        watchId = options["--watch"],
+        idempotencyKey = options["--idempotency-key"];
+      if (
+        !isValue(projectId) ||
+        !isValue(idempotencyKey) ||
+        (environment !== "dev" && environment !== "prod")
+      )
+        throw new InvalidCommandError();
+      return {
+        kind: "database-watch-delete",
+        projectId,
+        environment,
+        watchId: contractValue(() => parseDatabaseWatchId(watchId)),
+        idempotencyKey,
+        yes: true,
+        credentialStore,
+      };
+    }
+    throw new InvalidCommandError();
+  }
   if (first === "database" && values[0] === "webhook") {
     values.shift();
     const subcommand = values.shift();

package/src/apps/product-cli/src/product-api.ts

@@ -33,6 +33,9 @@ import {
   assertDatabaseWebhookDeliveryPage,
   assertDatabaseWebhookPage,
   assertDatabaseWebhookReplayAccepted,
+  assertDatabaseWatch,
+  assertDatabaseWatchDeleted,
+  assertDatabaseWatchPage,
   assertDatabaseWebhookTest,
   type DatabaseExecutionUsagePage,
   type DatabaseSchedule,
@@ -45,7 +48,11 @@ import {
   type DatabaseWebhookCreated,
   type DatabaseWebhookDeleted,
   type DatabaseWebhookDeliveryPage,
-  type DatabaseWebhookEventType,
+  type DatabaseWatch,
+  type DatabaseWatchDeleted,
+  type DatabaseWatchPage,
+  type DatabaseWatchRequest,
+  type DatabaseWebhookEventPattern,
   type DatabaseWebhookPage,
   type DatabaseWebhookReplayAccepted,
   type DatabaseWebhookTestResult,
@@ -152,6 +159,9 @@ import {
   getProjectDatabaseWebhook,
   deleteProjectDatabaseWebhook,
   testProjectDatabaseWebhook,
+  createProjectDatabaseWatch,
+  listProjectDatabaseWatches,
+  deleteProjectDatabaseWatch,
   listProjectDatabaseWebhookDeliveries,
   replayProjectDatabaseWebhookDelivery,
   setProjectDatabaseSchedule,
@@ -328,7 +338,7 @@ export interface ProductApi {
     readonly environment: "dev" | "prod";
     readonly idempotencyKey: string;
     readonly url: string;
-    readonly eventTypes: readonly DatabaseWebhookEventType[];
+    readonly eventTypes: readonly DatabaseWebhookEventPattern[];
     readonly headers: Readonly<Record<string, string>>;
   }): Promise<DatabaseWebhookCreated>;
   listProjectDatabaseWebhooks(input: {
@@ -350,6 +360,22 @@ export interface ProductApi {
     readonly environment: "dev" | "prod";
     readonly webhookId: string;
   }): Promise<DatabaseWebhookTestResult>;
+  createProjectDatabaseWatch(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly idempotencyKey: string;
+    readonly request: DatabaseWatchRequest;
+  }): Promise<DatabaseWatch>;
+  listProjectDatabaseWatches(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+  }): Promise<DatabaseWatchPage>;
+  deleteProjectDatabaseWatch(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly idempotencyKey: string;
+    readonly watchId: string;
+  }): Promise<DatabaseWatchDeleted>;
   listProjectDatabaseWebhookDeliveries(input: {
     readonly projectId: string;
     readonly environment: "dev" | "prod";
@@ -566,6 +592,7 @@ export interface ProductApi {
 
 /** A webhook answer that names another environment, webhook or delivery than the request did. */
 const WEBHOOK_SCOPE_MISMATCH = "Webhook response scope mismatch";
+const WATCH_SCOPE_MISMATCH = "Watch response scope mismatch";
 /** A schedule answer that names another environment or schedule than the request did. */
 const SCHEDULE_SCOPE_MISMATCH = "Schedule response scope mismatch";
 
@@ -889,6 +916,63 @@ export class GeneratedSdkProductApi implements ProductApi {
     return value;
   }
 
+  public async createProjectDatabaseWatch(
+    input: Parameters<ProductApi["createProjectDatabaseWatch"]>[0],
+  ): Promise<DatabaseWatch> {
+    const value = await createProjectDatabaseWatch(
+      {
+        project_id: input.projectId,
+        "Idempotency-Key": input.idempotencyKey,
+        databaseWatchCreateRequest: {
+          environment: input.environment,
+          schema: input.request.schema,
+          table: input.request.table,
+          columns: [...input.request.columns],
+          operations: [...input.request.operations],
+        },
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWatch(value);
+    if (
+      value.environment !== input.environment ||
+      value.schema !== input.request.schema ||
+      value.table !== input.request.table
+    )
+      throw new TypeError(WATCH_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseWatches(
+    input: Parameters<ProductApi["listProjectDatabaseWatches"]>[0],
+  ): Promise<DatabaseWatchPage> {
+    const value = await listProjectDatabaseWatches(
+      { project_id: input.projectId, environment: input.environment },
+      { client: this.#client },
+    );
+    assertDatabaseWatchPage(value);
+    if (value.items.some((item) => item.environment !== input.environment))
+      throw new TypeError(WATCH_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async deleteProjectDatabaseWatch(
+    input: Parameters<ProductApi["deleteProjectDatabaseWatch"]>[0],
+  ): Promise<DatabaseWatchDeleted> {
+    const value = await deleteProjectDatabaseWatch(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        "Idempotency-Key": input.idempotencyKey,
+        watch_id: input.watchId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWatchDeleted(value);
+    if (value.id !== input.watchId) throw new TypeError(WATCH_SCOPE_MISMATCH);
+    return value;
+  }
+
   /** The signing secret exists only in this answer; the CLI prints it once and stores nothing. */
   public async createProjectDatabaseWebhook(
     input: Parameters<ProductApi["createProjectDatabaseWebhook"]>[0],