@amerged/ohmyhost-cli 0.1.44 → 0.1.46

package/src/packages/contracts/src/database-migration-capture.ts

@@ -0,0 +1,177 @@
+import {
+  DATABASE_WATCH_MAX_COLUMNS,
+  DATABASE_WATCH_OPERATIONS,
+  isDatabaseWatchIdentifier,
+  isDatabaseWatchSchema,
+  type DatabaseWatchOperation,
+} from "./database-events.js";
+import { DatabaseMigrationAdmissionError } from "./database-migration-errors.js";
+import { isSqlKeyword, type MigrationSqlToken } from "./database-migration-lexical.js";
+
+export interface DatabaseMigrationCaptureTrigger {
+  readonly trigger: string;
+  readonly schema: string;
+  readonly table: string;
+  readonly operations: readonly DatabaseWatchOperation[];
+  readonly columns: readonly string[];
+}
+
+export interface MigrationCaptureStatement {
+  readonly target: DatabaseMigrationCaptureTrigger;
+  /** The tokens before the pgcf.capture function name, which still pass the ordinary references check. */
+  readonly header: readonly MigrationSqlToken[];
+}
+
+const MAX_NAME_BYTES = 63;
+
+/**
+ * Reads the one trigger form PGCF admits on an existing table:
+ * CREATE TRIGGER name AFTER INSERT [OR UPDATE] [OR DELETE] ON schema.table FOR EACH ROW
+ * EXECUTE FUNCTION pgcf.capture('column', ...). Returns undefined for every statement that does not
+ * name pgcf, so ordinary triggers keep their existing admission. Anything else that names pgcf throws.
+ */
+export function readMigrationCaptureTrigger(
+  tokens: readonly MigrationSqlToken[],
+): MigrationCaptureStatement | undefined {
+  if (!isSqlKeyword(tokens[0], "create") || !isSqlKeyword(tokens[1], "trigger")) return undefined;
+  if (!tokens.some((token) => isNamedPgcf(token, true))) return undefined;
+  return new CaptureReader(tokens).read();
+}
+
+class CaptureReader {
+  private position = 2;
+
+  public constructor(private readonly tokens: readonly MigrationSqlToken[]) {}
+
+  public read(): MigrationCaptureStatement {
+    const trigger = this.triggerName();
+    this.expectKeyword("after");
+    const operations = this.operations();
+    this.expectKeyword("on");
+    const schema = this.name();
+    this.expectSymbol(".");
+    const table = this.name();
+    if (!isDatabaseWatchSchema(schema)) throw unsupported();
+    for (const keyword of ["for", "each", "row", "execute", "function"]) {
+      this.expectKeyword(keyword);
+    }
+    const header = this.tokens.slice(0, this.position);
+    if (!isNamedPgcf(this.token(), false)) throw unsupported();
+    this.position += 1;
+    this.expectSymbol(".");
+    this.expectCapture();
+    this.expectSymbol("(");
+    const columns = this.columns();
+    this.expectSymbol(")");
+    if (this.position !== this.tokens.length) throw unsupported();
+    return Object.freeze({
+      target: Object.freeze({ trigger, schema, table, operations, columns }),
+      header,
+    });
+  }
+
+  private triggerName(): string {
+    const token = this.token();
+    if (
+      (token.kind !== "word" && token.kind !== "identifier") ||
+      !isDatabaseWatchIdentifier(token.value)
+    ) {
+      throw unsupported();
+    }
+    this.position += 1;
+    return token.value;
+  }
+
+  /** Table and schema names may be quoted identifiers; the executor checks the catalog for the exact name. */
+  private name(): string {
+    const token = this.token();
+    const valid =
+      token.kind === "word"
+        ? isDatabaseWatchIdentifier(token.value)
+        : token.kind === "identifier" && isQuotedName(token.value);
+    if (!valid) throw unsupported();
+    this.position += 1;
+    return token.value;
+  }
+
+  private operations(): readonly DatabaseWatchOperation[] {
+    const events: DatabaseWatchOperation[] = [];
+    do {
+      const token = this.token();
+      const operation = DATABASE_WATCH_OPERATIONS.find((name) => isSqlKeyword(token, name));
+      if (operation === undefined || events.includes(operation)) throw unsupported();
+      this.position += 1;
+      events.push(operation);
+    } while (this.takeKeyword("or"));
+    return DATABASE_WATCH_OPERATIONS.filter((operation) => events.includes(operation));
+  }
+
+  private expectCapture(): void {
+    const token = this.token();
+    if ((token.kind !== "word" && token.kind !== "identifier") || token.value !== "capture") {
+      throw unsupported();
+    }
+    this.position += 1;
+  }
+
+  private columns(): readonly string[] {
+    const columns: string[] = [];
+    do {
+      const token = this.token();
+      if (
+        columns.length >= DATABASE_WATCH_MAX_COLUMNS ||
+        token.kind !== "string" ||
+        token.text !== `'${token.value}'` ||
+        !isDatabaseWatchIdentifier(token.value) ||
+        columns.includes(token.value)
+      ) {
+        throw unsupported();
+      }
+      this.position += 1;
+      columns.push(token.value);
+    } while (this.takeSymbol(","));
+    return columns;
+  }
+
+  private token(): MigrationSqlToken {
+    const token = this.tokens[this.position];
+    if (token === undefined) throw unsupported();
+    return token;
+  }
+
+  private takeKeyword(keyword: string): boolean {
+    if (!isSqlKeyword(this.tokens[this.position], keyword)) return false;
+    this.position += 1;
+    return true;
+  }
+
+  private expectKeyword(keyword: string): void {
+    if (!this.takeKeyword(keyword)) throw unsupported();
+  }
+
+  private takeSymbol(symbol: string): boolean {
+    const token = this.tokens[this.position];
+    if (token?.kind !== "symbol" || token.value !== symbol) return false;
+    this.position += 1;
+    return true;
+  }
+
+  private expectSymbol(symbol: string): void {
+    if (!this.takeSymbol(symbol)) throw unsupported();
+  }
+}
+
+/** The gate ignores case; the function name itself must be exactly pgcf, so "PGCF" is refused later. */
+function isNamedPgcf(token: MigrationSqlToken, ignoreCase: boolean): boolean {
+  if (token.kind !== "word" && token.kind !== "identifier") return false;
+  return ignoreCase ? token.value.toLowerCase() === "pgcf" : token.value === "pgcf";
+}
+
+function isQuotedName(value: string): boolean {
+  const bytes = new TextEncoder().encode(value).byteLength;
+  return bytes >= 1 && bytes <= MAX_NAME_BYTES;
+}
+
+function unsupported(): DatabaseMigrationAdmissionError {
+  return new DatabaseMigrationAdmissionError("unsupported");
+}

package/src/packages/contracts/src/database-migration-lexical.ts

@@ -144,6 +144,7 @@ export function rejectMigrationSqlReferences(
     const token = tokens[index];
     if (token?.kind !== "word" && token?.kind !== "identifier") continue;
     const value = token.value.toLowerCase();
+    if (value === "pgcf") throw new DatabaseMigrationAdmissionError("unsupported");
     if (value === "ohmyhost") {
       if (
         allowIdentityHelpers &&

package/src/packages/contracts/src/database-tables.ts

@@ -0,0 +1,317 @@
+/** Column types a created table may declare; the closed list keeps type text out of the DDL. */
+export const DATABASE_TABLE_COLUMN_TYPES = [
+  "text",
+  "integer",
+  "bigint",
+  "boolean",
+  "numeric",
+  "double precision",
+  "timestamptz",
+  "date",
+  "uuid",
+  "jsonb",
+] as const;
+export type DatabaseTableColumnType = (typeof DATABASE_TABLE_COLUMN_TYPES)[number];
+/** `now` is DEFAULT now() on timestamptz; `uuid` is DEFAULT gen_random_uuid() on uuid. */
+export const DATABASE_TABLE_DEFAULTS = ["now", "uuid"] as const;
+export type DatabaseTableDefault = (typeof DATABASE_TABLE_DEFAULTS)[number];
+export const DATABASE_TABLE_MAX_COLUMNS = 64;
+export const DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS = 8;
+/** Ordinary and partitioned tables that a database may hold in its public schema. */
+export const DATABASE_TABLE_LIMIT = 100;
+export const DATABASE_TABLE_SCHEMA = "public";
+
+const DATABASE_TABLE_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_]{0,62}$/u;
+/** PostgreSQL reserved words: a table or column of such a name would need quoting everywhere it is used. */
+const RESERVED_WORDS: ReadonlySet<string> = new Set([
+  "all",
+  "analyse",
+  "analyze",
+  "and",
+  "any",
+  "array",
+  "as",
+  "asc",
+  "asymmetric",
+  "both",
+  "case",
+  "cast",
+  "check",
+  "collate",
+  "column",
+  "constraint",
+  "create",
+  "current_catalog",
+  "current_date",
+  "current_role",
+  "current_time",
+  "current_timestamp",
+  "current_user",
+  "default",
+  "deferrable",
+  "desc",
+  "distinct",
+  "do",
+  "else",
+  "end",
+  "except",
+  "false",
+  "fetch",
+  "for",
+  "foreign",
+  "from",
+  "grant",
+  "group",
+  "having",
+  "in",
+  "initially",
+  "intersect",
+  "into",
+  "lateral",
+  "leading",
+  "limit",
+  "localtime",
+  "localtimestamp",
+  "not",
+  "null",
+  "offset",
+  "on",
+  "only",
+  "or",
+  "order",
+  "placing",
+  "primary",
+  "references",
+  "returning",
+  "select",
+  "session_user",
+  "some",
+  "symmetric",
+  "table",
+  "then",
+  "to",
+  "trailing",
+  "true",
+  "union",
+  "unique",
+  "user",
+  "using",
+  "variadic",
+  "when",
+  "where",
+  "window",
+  "with",
+]);
+
+export interface DatabaseTableColumn {
+  readonly name: string;
+  readonly type: DatabaseTableColumnType;
+  readonly nullable: boolean;
+  readonly identity: boolean;
+  readonly default: DatabaseTableDefault | null;
+}
+
+/** A create request after parsing: nullable is concrete and primaryKey is empty when the request names none. */
+export interface DatabaseTableRequest {
+  readonly table: string;
+  readonly columns: readonly DatabaseTableColumn[];
+  readonly primaryKey: readonly string[];
+}
+
+export interface DatabaseTable {
+  readonly schema: typeof DATABASE_TABLE_SCHEMA;
+  readonly table: string;
+  readonly columns: readonly DatabaseTableColumn[];
+  readonly primaryKey: readonly string[];
+}
+
+export interface DatabaseTableCreated {
+  readonly table: DatabaseTable;
+  readonly created: boolean;
+}
+
+interface ColumnInput {
+  readonly name: string;
+  readonly type: DatabaseTableColumnType;
+  readonly nullable: boolean | undefined;
+  readonly identity: boolean;
+  readonly default: DatabaseTableDefault | null;
+}
+
+/** Identifiers are plain lower-case SQL names; the renderer quotes them and no other caller text reaches the DDL. */
+export function isDatabaseTableIdentifier(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    DATABASE_TABLE_IDENTIFIER_PATTERN.test(value) &&
+    !value.startsWith("pg_") &&
+    !RESERVED_WORDS.has(value)
+  );
+}
+
+export function parseDatabaseTableCreateRequest(value: unknown): DatabaseTableRequest {
+  if (
+    !record(value) ||
+    !onlyKeys(value, ["table", "columns", "primaryKey"]) ||
+    !isDatabaseTableIdentifier(value["table"]) ||
+    !Array.isArray(value["columns"]) ||
+    value["columns"].length < 1 ||
+    value["columns"].length > DATABASE_TABLE_MAX_COLUMNS
+  )
+    throw new TypeError("Invalid database table request");
+  const inputs = value["columns"].map(parseColumn);
+  const names = inputs.map((column) => column.name);
+  if (new Set(names).size !== names.length || inputs.filter((column) => column.identity).length > 1)
+    throw new TypeError("Invalid database table request");
+  const primaryKey = parsePrimaryKey(value["primaryKey"], names);
+  return {
+    table: value["table"],
+    columns: inputs.map((column) => completeColumn(column, primaryKey.includes(column.name))),
+    primaryKey,
+  };
+}
+
+/**
+ * The one CREATE TABLE statement of a request, in the public schema. Identifiers are validated again here, so the
+ * renderer is safe for any caller; the statement has no trailing semicolon.
+ */
+export function renderCreateTableStatement(request: DatabaseTableRequest): string {
+  const definitions = request.columns.map(renderColumn);
+  if (request.primaryKey.length > 0)
+    definitions.push(`PRIMARY KEY (${request.primaryKey.map(quoted).join(",")})`);
+  return `CREATE TABLE ${databaseTableReference(request.table)} (${definitions.join(", ")})`;
+}
+
+/** The quoted, schema-qualified name of a table of the public schema, as SQL statements use it. */
+export function databaseTableReference(table: string): string {
+  return `${quoted(DATABASE_TABLE_SCHEMA)}.${quoted(table)}`;
+}
+
+export function assertDatabaseTableCreated(value: unknown): asserts value is DatabaseTableCreated {
+  if (
+    !record(value) ||
+    !exact(value, ["table", "created"]) ||
+    typeof value["created"] !== "boolean" ||
+    !isDatabaseTable(value["table"])
+  )
+    throw new TypeError("Invalid database table");
+}
+
+function parseColumn(value: unknown): ColumnInput {
+  if (
+    !record(value) ||
+    !onlyKeys(value, ["name", "type", "nullable", "identity", "default"]) ||
+    !isDatabaseTableIdentifier(value["name"]) ||
+    !oneOf(DATABASE_TABLE_COLUMN_TYPES, value["type"]) ||
+    (value["nullable"] !== undefined && typeof value["nullable"] !== "boolean") ||
+    (value["identity"] !== undefined && typeof value["identity"] !== "boolean") ||
+    (value["default"] !== undefined && !oneOf(DATABASE_TABLE_DEFAULTS, value["default"]))
+  )
+    throw new TypeError("Invalid database table request");
+  const type = value["type"];
+  const identity = value["identity"] === true;
+  const defaultValue = value["default"] ?? null;
+  if (identity && type !== "integer" && type !== "bigint")
+    throw new TypeError("Invalid database table request");
+  if (identity && defaultValue !== null) throw new TypeError("Invalid database table request");
+  if (defaultValue === "now" && type !== "timestamptz")
+    throw new TypeError("Invalid database table request");
+  if (defaultValue === "uuid" && type !== "uuid")
+    throw new TypeError("Invalid database table request");
+  return {
+    name: value["name"],
+    type,
+    nullable: value["nullable"],
+    identity,
+    default: defaultValue,
+  };
+}
+
+function parsePrimaryKey(value: unknown, names: readonly string[]): readonly string[] {
+  if (value === undefined) return [];
+  if (
+    !Array.isArray(value) ||
+    value.length < 1 ||
+    value.length > DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS ||
+    new Set(value).size !== value.length ||
+    !value.every((name) => typeof name === "string" && names.includes(name))
+  )
+    throw new TypeError("Invalid database table request");
+  return value as string[];
+}
+
+/** Identity and primary key columns are NOT NULL; asking for a nullable one of them is a contradiction. */
+function completeColumn(column: ColumnInput, keyed: boolean): DatabaseTableColumn {
+  const required = column.identity || keyed;
+  if (required && column.nullable === true) throw new TypeError("Invalid database table request");
+  return {
+    name: column.name,
+    type: column.type,
+    nullable: required ? false : (column.nullable ?? true),
+    identity: column.identity,
+    default: column.default,
+  };
+}
+
+function renderColumn(column: DatabaseTableColumn): string {
+  if (!oneOf(DATABASE_TABLE_COLUMN_TYPES, column.type))
+    throw new TypeError("Invalid database table column type");
+  const parts = [quoted(column.name), column.type];
+  if (!column.nullable) parts.push("NOT NULL");
+  if (column.identity) parts.push("GENERATED ALWAYS AS IDENTITY");
+  if (column.default === "now") parts.push("DEFAULT now()");
+  if (column.default === "uuid") parts.push("DEFAULT gen_random_uuid()");
+  return parts.join(" ");
+}
+
+function quoted(identifier: string): string {
+  if (!isDatabaseTableIdentifier(identifier))
+    throw new TypeError("Invalid database table identifier");
+  return `"${identifier}"`;
+}
+
+function isDatabaseTable(value: unknown): boolean {
+  if (!record(value) || !exact(value, ["schema", "table", "columns", "primaryKey"])) return false;
+  const columns = value["columns"];
+  const primaryKey = value["primaryKey"];
+  if (
+    value["schema"] !== DATABASE_TABLE_SCHEMA ||
+    !isDatabaseTableIdentifier(value["table"]) ||
+    !Array.isArray(columns) ||
+    columns.length < 1 ||
+    columns.length > DATABASE_TABLE_MAX_COLUMNS ||
+    !columns.every(isDatabaseTableColumn) ||
+    !Array.isArray(primaryKey) ||
+    primaryKey.length > DATABASE_TABLE_MAX_PRIMARY_KEY_COLUMNS
+  )
+    return false;
+  const names = columns.map((column) => column.name);
+  return primaryKey.every((name) => typeof name === "string" && names.includes(name));
+}
+
+function isDatabaseTableColumn(value: unknown): value is DatabaseTableColumn {
+  return (
+    record(value) &&
+    exact(value, ["name", "type", "nullable", "identity", "default"]) &&
+    isDatabaseTableIdentifier(value["name"]) &&
+    oneOf(DATABASE_TABLE_COLUMN_TYPES, value["type"]) &&
+    typeof value["nullable"] === "boolean" &&
+    typeof value["identity"] === "boolean" &&
+    (value["default"] === null || oneOf(DATABASE_TABLE_DEFAULTS, value["default"]))
+  );
+}
+
+function oneOf<T extends string>(allowed: readonly T[], value: unknown): value is T {
+  return typeof value === "string" && (allowed as readonly string[]).includes(value);
+}
+
+function record(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function onlyKeys(value: Record<string, unknown>, allowed: readonly string[]): boolean {
+  return Object.keys(value).every((key) => allowed.includes(key));
+}
+
+function exact(value: Record<string, unknown>, keys: readonly string[]): boolean {
+  return Object.keys(value).sort().join(",") === [...keys].sort().join(",");
+}

package/src/packages/contracts/src/problem-policy.ts

@@ -192,6 +192,55 @@ export const PROBLEM_POLICY = {
       "The platform is still retrying this webhook delivery. Read the delivery in the delivery list; replay it only if it ends dead_lettered or the receiver needs the event again.",
     title: "Webhook delivery still pending",
   },
+  database_watch_limit: {
+    status: 409,
+    retryable: false,
+    action:
+      "List the project's database watches for this environment and delete one you no longer need, then create the watch again.",
+    title: "Database watch limit reached",
+  },
+  database_watch_table_unavailable: {
+    status: 409,
+    retryable: false,
+    action:
+      "The table must exist as an ordinary table owned by the application, created by a deployed migration; views, partitions, temporary tables and the schemas pgcf, ohmyhost, information_schema and pg_* cannot be watched. Fix the name or deploy the migration, then create the watch again.",
+    title: "Table cannot be watched",
+  },
+  database_watch_column_unavailable: {
+    status: 409,
+    retryable: false,
+    action:
+      "List only existing column names exactly as written, names are case-sensitive. Delete the watch before a migration drops a published column, because the write would fail.",
+    title: "Watched column does not exist",
+  },
+  database_watch_events_unavailable: {
+    status: 409,
+    retryable: false,
+    action:
+      "The platform event schema is installed when the database wakes: run any query against that environment, wait for the answer, then create the watch again. If it still fails, report the request_id through feedback.",
+    title: "Database events not installed yet",
+  },
+  database_watch_conflict: {
+    status: 409,
+    retryable: false,
+    action:
+      "A migration already attaches a capture trigger to this table: keep it and skip the watch, or remove it from the migrations, deploy and create the watch again. A table carries one capture trigger.",
+    title: "Table already has a capture trigger",
+  },
+  database_table_conflict: {
+    status: 409,
+    retryable: false,
+    action:
+      "A table with this name already exists with another definition. Choose another table name, or create the table again with the same columns, types, nullability, identity, defaults and primary key it has.",
+    title: "Table already exists with another definition",
+  },
+  database_table_limit: {
+    status: 409,
+    retryable: false,
+    action:
+      "This database already holds the maximum number of tables in its public schema, so no table can be added. Use an existing table, or remove a table you no longer need through a deployed migration, then create the table again.",
+    title: "Database table limit reached",
+  },
   project_notes_conflict: {
     status: 409,
     retryable: false,
@@ -502,7 +551,7 @@ export const PROBLEM_POLICY = {
     status: 503,
     retryable: false,
     action:
-      "Report the platform user-key permission configuration through feedback. Repeated login or creation will not fix it.",
+      "Report the platform user-key permission configuration through feedback with this request_id; it affects every token the same way, whatever the integration. Repeated login does not fix it. After the platform confirms the fix, repeat the same create with the same name and Idempotency-Key.",
     title: "Token permissions unavailable",
   },
   reconciliation_exhausted: {

package/src/packages/sdk-ts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ohmyhost/sdk-ts",
-  "version": "0.1.44",
+  "version": "0.1.46",
   "private": true,
   "type": "module",
   "exports": {

package/src/packages/sdk-ts/src/generated/index.ts

@@ -23,6 +23,8 @@ export {
   createOrganization,
   createProject,
   createProjectDatabaseAccess,
+  createProjectDatabaseTable,
+  createProjectDatabaseWatch,
   createProjectDatabaseWebhook,
   createProjectDataChange,
   createProjectDevAccessTicket,
@@ -35,6 +37,7 @@ export {
   deletePaidProjectDomain,
   deleteProject,
   deleteProjectDatabaseSchedule,
+  deleteProjectDatabaseWatch,
   deleteProjectDatabaseWebhook,
   detachProjectMailDomainBinding,
   diffManagedSource,
@@ -91,6 +94,7 @@ export {
   listProjectDatabaseAccess,
   listProjectDatabaseScheduleRuns,
   listProjectDatabaseSchedules,
+  listProjectDatabaseWatches,
   listProjectDatabaseWebhookDeliveries,
   listProjectDatabaseWebhooks,
   listProjects,
@@ -271,6 +275,16 @@ export type {
   CreateProjectDatabaseAccessErrors,
   CreateProjectDatabaseAccessResponse,
   CreateProjectDatabaseAccessResponses,
+  CreateProjectDatabaseTableData,
+  CreateProjectDatabaseTableError,
+  CreateProjectDatabaseTableErrors,
+  CreateProjectDatabaseTableResponse,
+  CreateProjectDatabaseTableResponses,
+  CreateProjectDatabaseWatchData,
+  CreateProjectDatabaseWatchError,
+  CreateProjectDatabaseWatchErrors,
+  CreateProjectDatabaseWatchResponse,
+  CreateProjectDatabaseWatchResponses,
   CreateProjectDatabaseWebhookData,
   CreateProjectDatabaseWebhookError,
   CreateProjectDatabaseWebhookErrors,
@@ -325,6 +339,17 @@ export type {
   DatabaseScheduleRunAccepted,
   DatabaseScheduleRunPage,
   DatabaseScheduleSetRequest,
+  DatabaseTable,
+  DatabaseTableColumn,
+  DatabaseTableColumnRequest,
+  DatabaseTableColumnType,
+  DatabaseTableCreated,
+  DatabaseTableCreateRequest,
+  DatabaseWatch,
+  DatabaseWatchCreateRequest,
+  DatabaseWatchDeleted,
+  DatabaseWatchId,
+  DatabaseWatchPage,
   DatabaseWebhook,
   DatabaseWebhookCreated,
   DatabaseWebhookCreateRequest,
@@ -332,6 +357,8 @@ export type {
   DatabaseWebhookDelivery,
   DatabaseWebhookDeliveryId,
   DatabaseWebhookDeliveryPage,
+  DatabaseWebhookEventPattern,
+  DatabaseWebhookEventPatternWritable,
   DatabaseWebhookEventType,
   DatabaseWebhookId,
   DatabaseWebhookPage,
@@ -364,6 +391,11 @@ export type {
   DeleteProjectDatabaseScheduleErrors,
   DeleteProjectDatabaseScheduleResponse,
   DeleteProjectDatabaseScheduleResponses,
+  DeleteProjectDatabaseWatchData,
+  DeleteProjectDatabaseWatchError,
+  DeleteProjectDatabaseWatchErrors,
+  DeleteProjectDatabaseWatchResponse,
+  DeleteProjectDatabaseWatchResponses,
   DeleteProjectDatabaseWebhookData,
   DeleteProjectDatabaseWebhookError,
   DeleteProjectDatabaseWebhookErrors,
@@ -685,6 +717,11 @@ export type {
   ListProjectDatabaseSchedulesErrors,
   ListProjectDatabaseSchedulesResponse,
   ListProjectDatabaseSchedulesResponses,
+  ListProjectDatabaseWatchesData,
+  ListProjectDatabaseWatchesError,
+  ListProjectDatabaseWatchesErrors,
+  ListProjectDatabaseWatchesResponse,
+  ListProjectDatabaseWatchesResponses,
   ListProjectDatabaseWebhookDeliveriesData,
   ListProjectDatabaseWebhookDeliveriesError,
   ListProjectDatabaseWebhookDeliveriesErrors,