@amerged/ohmyhost-mcp 0.1.44 → 0.1.46

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

@@ -6,10 +6,17 @@ import {
   parseDatabaseListLimit,
   parseDatabaseScheduleName,
   parseDatabaseUsageWindow,
+  parseDatabaseWatchCreateRequest,
+  parseDatabaseWatchId,
   parseDatabaseWebhookCreateRequest,
   parseDatabaseWebhookId,
-  type DatabaseWebhookEventType,
+  type DatabaseWatchRequest,
+  type DatabaseWebhookEventPattern,
 } from "@ohmyhost/contracts/database-events";
+import {
+  DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS,
+  isDatabaseTableIdentifier,
+} from "@ohmyhost/contracts/database-tables";
 import {
   databaseSizeForMemory,
   type DatabaseComputeSelection,
@@ -404,12 +411,47 @@ 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-table-create";
+      readonly projectId: string;
+      readonly environment: "dev" | "prod";
+      readonly table: string;
+      readonly columnsFile: string;
+      readonly primaryKey: readonly string[];
+      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 +1045,10 @@ export type RecognizedCommandLabel =
   | "database access create"
   | "database access list"
   | "database access revoke"
+  | "database watch create"
+  | "database watch list"
+  | "database watch delete"
+  | "database table create"
   | "database webhook create"
   | "database webhook list"
   | "database webhook get"
@@ -1174,6 +1220,13 @@ 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] === "table" && values[1] === "create")
+      return "database table create";
     if (value === "database" && values[0] === "webhook") {
       if (values[1] === "create") return "database webhook create";
       if (values[1] === "list") return "database webhook list";
@@ -2063,6 +2116,137 @@ 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] === "table") {
+    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",
+        "--columns-file",
+        "--primary-key",
+        "--idempotency-key",
+      ]);
+      const projectId = options["--project"],
+        environment = options["--environment"],
+        table = options["--table"],
+        columnsFile = options["--columns-file"],
+        primaryKey = options["--primary-key"],
+        idempotencyKey = options["--idempotency-key"];
+      const keyNames = primaryKey === undefined ? [] : primaryKey.split(",");
+      if (
+        !isValue(projectId) ||
+        !isValue(idempotencyKey) ||
+        !isValue(table) ||
+        !isValue(columnsFile) ||
+        (primaryKey !== undefined && !keyNames.every(isDatabaseTableIdentifier)) ||
+        keyNames.length > DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS ||
+        !isDatabaseTableIdentifier(table) ||
+        (environment !== "dev" && environment !== "prod")
+      )
+        throw new InvalidCommandError();
+      return {
+        kind: "database-table-create",
+        projectId,
+        environment,
+        table,
+        columnsFile,
+        primaryKey: keyNames,
+        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

@@ -20,6 +20,13 @@ import {
   type ProjectDatabaseWriteReceipt,
 } from "@ohmyhost/contracts/database-access";
 import { assertDatabaseCompute, type DatabaseCompute } from "@ohmyhost/contracts/database-compute";
+import {
+  DATABASE_TABLE_COLUMN_TYPES,
+  DATABASE_TABLE_DEFAULTS,
+  isDatabaseTableIdentifier,
+  type DatabaseTableColumnType,
+  type DatabaseTableDefault,
+} from "@ohmyhost/contracts/database-tables";
 import {
   assertDatabaseExecutionUsagePage,
   assertDatabaseSchedule,
@@ -33,6 +40,9 @@ import {
   assertDatabaseWebhookDeliveryPage,
   assertDatabaseWebhookPage,
   assertDatabaseWebhookReplayAccepted,
+  assertDatabaseWatch,
+  assertDatabaseWatchDeleted,
+  assertDatabaseWatchPage,
   assertDatabaseWebhookTest,
   type DatabaseExecutionUsagePage,
   type DatabaseSchedule,
@@ -45,7 +55,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 +166,10 @@ import {
   getProjectDatabaseWebhook,
   deleteProjectDatabaseWebhook,
   testProjectDatabaseWebhook,
+  createProjectDatabaseWatch,
+  listProjectDatabaseWatches,
+  deleteProjectDatabaseWatch,
+  createProjectDatabaseTable,
   listProjectDatabaseWebhookDeliveries,
   replayProjectDatabaseWebhookDelivery,
   setProjectDatabaseSchedule,
@@ -205,6 +223,39 @@ export interface ProjectCreateInput {
   readonly idempotencyKey: string;
 }
 
+/** One column of a table to create; nullable, identity and default are optional as the REST body allows. */
+export interface DatabaseTableColumnInput {
+  readonly name: string;
+  readonly type: DatabaseTableColumnType;
+  readonly nullable?: boolean;
+  readonly identity?: boolean;
+  readonly default?: DatabaseTableDefault;
+}
+
+export interface DatabaseTableCreateInput {
+  readonly table: string;
+  readonly columns: readonly DatabaseTableColumnInput[];
+  readonly primaryKey: readonly string[];
+}
+
+/** The created or identical existing table, every column with its concrete nullability and default. */
+export interface DatabaseTableAnswer {
+  readonly table: {
+    readonly environment: "dev" | "prod";
+    readonly schema: "public";
+    readonly table: string;
+    readonly columns: readonly {
+      readonly name: string;
+      readonly type: DatabaseTableColumnType;
+      readonly nullable: boolean;
+      readonly identity: boolean;
+      readonly default: DatabaseTableDefault | null;
+    }[];
+    readonly primary_key: readonly string[];
+    readonly created: boolean;
+  };
+}
+
 export interface ProductApi {
   readonly managedSource?: ManagedSourceApi;
   planProjectDataChange(input: {
@@ -328,7 +379,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 +401,28 @@ 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>;
+  createProjectDatabaseTable(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly idempotencyKey: string;
+    readonly request: DatabaseTableCreateInput;
+  }): Promise<DatabaseTableAnswer>;
   listProjectDatabaseWebhookDeliveries(input: {
     readonly projectId: string;
     readonly environment: "dev" | "prod";
@@ -566,9 +639,55 @@ 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";
+const TABLE_SCOPE_MISMATCH = "Table response scope mismatch";
 /** A schedule answer that names another environment or schedule than the request did. */
 const SCHEDULE_SCOPE_MISMATCH = "Schedule response scope mismatch";
 
+/** The REST answer read exactly: no extra keys, closed column types and defaults, keys among the columns. */
+export function assertDatabaseTableAnswer(value: unknown): asserts value is DatabaseTableAnswer {
+  const table = isRecordValue(value) ? value["table"] : undefined;
+  const columns = isRecordValue(table) ? table["columns"] : undefined;
+  const primaryKey = isRecordValue(table) ? table["primary_key"] : undefined;
+  if (
+    !isRecordValue(table) ||
+    !hasExactKeys(table, ["environment", "schema", "table", "columns", "primary_key", "created"]) ||
+    (table["environment"] !== "dev" && table["environment"] !== "prod") ||
+    table["schema"] !== "public" ||
+    !isDatabaseTableIdentifier(table["table"]) ||
+    typeof table["created"] !== "boolean" ||
+    !Array.isArray(columns) ||
+    columns.length < 1 ||
+    !columns.every(isDatabaseTableAnswerColumn) ||
+    !Array.isArray(primaryKey) ||
+    !primaryKey.every((name: unknown) =>
+      columns.some((column: Record<string, unknown>) => column["name"] === name),
+    )
+  )
+    throw new TypeError("Invalid database table answer");
+}
+
+function isDatabaseTableAnswerColumn(value: unknown): boolean {
+  return (
+    isRecordValue(value) &&
+    hasExactKeys(value, ["name", "type", "nullable", "identity", "default"]) &&
+    isDatabaseTableIdentifier(value["name"]) &&
+    (DATABASE_TABLE_COLUMN_TYPES as readonly unknown[]).includes(value["type"]) &&
+    typeof value["nullable"] === "boolean" &&
+    typeof value["identity"] === "boolean" &&
+    (value["default"] === null ||
+      (DATABASE_TABLE_DEFAULTS as readonly unknown[]).includes(value["default"]))
+  );
+}
+
+function isRecordValue(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function hasExactKeys(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
+}
+
 export class GeneratedSdkProductApi implements ProductApi {
   readonly #client: OhMyHostClient;
   public readonly managedSource: ManagedSourceApi;
@@ -889,6 +1008,87 @@ 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;
+  }
+
+  public async createProjectDatabaseTable(
+    input: Parameters<ProductApi["createProjectDatabaseTable"]>[0],
+  ): Promise<DatabaseTableAnswer> {
+    const value = await createProjectDatabaseTable(
+      {
+        project_id: input.projectId,
+        "Idempotency-Key": input.idempotencyKey,
+        databaseTableCreateRequest: {
+          environment: input.environment,
+          table: input.request.table,
+          columns: [...input.request.columns],
+          ...(input.request.primaryKey.length === 0
+            ? {}
+            : { primary_key: [...input.request.primaryKey] }),
+        },
+      },
+      { client: this.#client },
+    );
+    assertDatabaseTableAnswer(value);
+    if (value.table.environment !== input.environment || value.table.table !== input.request.table)
+      throw new TypeError(TABLE_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],