@amerged/ohmyhost-cli 0.1.44 → 0.1.45

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

@@ -11,6 +11,13 @@ export const DATABASE_WEBHOOK_EVENT_TYPES = [
   "database.deleted",
 ] as const;
 export type DatabaseWebhookEventType = (typeof DATABASE_WEBHOOK_EVENT_TYPES)[number];
+/** Row-change events of a watched table; the topic is derived from the table name by dataEventTopic. */
+export type DatabaseDataEventType = `data.${string}`;
+export type DatabaseWebhookEventPattern = DatabaseWebhookEventType | DatabaseDataEventType;
+export const DATABASE_WATCH_OPERATIONS = ["insert", "update", "delete"] as const;
+export type DatabaseWatchOperation = (typeof DATABASE_WATCH_OPERATIONS)[number];
+export const DATABASE_WATCH_MAX_COLUMNS = 32;
+export const DATABASE_WATCH_DEFAULT_SCHEMA = "public";
 /** Per environment; the platform-wide provider cap is shared by every customer. */
 export const DATABASE_WEBHOOK_LIMIT = 5;
 export const DATABASE_WEBHOOK_MAX_EVENT_TYPES = 16;
@@ -66,9 +73,41 @@ export type DatabaseWebhookDeliveryState = "pending" | "delivered" | "dead_lette
 export type DatabaseWebhookDeliveryError = "timeout" | "network" | "http" | "expired" | "permanent";
 export type DatabaseWebhookTestError = "timeout" | "network" | "http";
 
+export interface DatabaseWatchRequest {
+  readonly schema: string;
+  readonly table: string;
+  readonly columns: readonly string[];
+  readonly operations: readonly DatabaseWatchOperation[];
+}
+
+export interface DatabaseWatchTarget {
+  readonly schema: string;
+  readonly table: string;
+}
+
+export interface DatabaseWatch {
+  readonly id: string;
+  readonly environment: DatabaseEnvironment;
+  readonly schema: string;
+  readonly table: string;
+  readonly columns: readonly string[];
+  readonly operations: readonly DatabaseWatchOperation[];
+  readonly topic: string;
+  readonly event_type: DatabaseDataEventType;
+}
+
+export interface DatabaseWatchPage {
+  readonly items: readonly DatabaseWatch[];
+}
+
+export interface DatabaseWatchDeleted {
+  readonly id: string;
+  readonly deleted: true;
+}
+
 export interface DatabaseWebhookCreateRequest {
   readonly url: string;
-  readonly event_types: readonly DatabaseWebhookEventType[];
+  readonly event_types: readonly DatabaseWebhookEventPattern[];
   readonly headers: Readonly<Record<string, string>>;
 }
 
@@ -90,7 +129,7 @@ export interface DatabaseWebhook {
   readonly id: string;
   readonly environment: DatabaseEnvironment;
   readonly url: string;
-  readonly event_types: readonly DatabaseWebhookEventType[];
+  readonly event_types: readonly DatabaseWebhookEventPattern[];
   readonly header_names: readonly string[];
   readonly created_at: string;
 }
@@ -112,7 +151,7 @@ export interface DatabaseWebhookDeleted {
 export interface DatabaseWebhookDelivery {
   readonly id: string;
   readonly event_id: string;
-  readonly event_type: DatabaseWebhookEventType;
+  readonly event_type: DatabaseWebhookEventType | DatabaseDataEventType;
   readonly webhook_id: string;
   readonly state: DatabaseWebhookDeliveryState;
   readonly attempts: number;
@@ -197,7 +236,23 @@ export interface DatabaseExecutionUsagePage {
 const WEBHOOK_KEYS = ["id", "environment", "url", "event_types", "header_names", "created_at"];
 const WEBHOOK_ID_PATTERN = /^whk_[a-z0-9]{20}$/u;
 const DELIVERY_ID_PATTERN = /^dlv_[0-9a-f]{20}$/u;
-const EVENT_ID_PATTERN = /^evt_[0-9a-f]{20}$/u;
+const EVENT_ID_PATTERN =
+  /^(?:evt_[0-9a-f]{20}|[a-z][a-z0-9]{19}:[1-9][0-9]{0,15}:[1-9][0-9]{0,15})$/u;
+const DATA_SUBSCRIPTION_PATTERN = /^data\.(?:\*|[a-z][a-z0-9_]{0,47})$/u;
+const DATA_EVENT_TYPE_PATTERN = /^data\.[a-z][a-z0-9_]{0,47}$/u;
+const DATABASE_WATCH_ID_PATTERN = /^pgcf_watch_[0-9a-f]{8}$/u;
+const DATABASE_WATCH_IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]{0,62}$/u;
+const DATABASE_WATCH_FORBIDDEN_SCHEMAS = ["information_schema", "pgcf", "ohmyhost"];
+const DATABASE_WATCH_KEYS = [
+  "id",
+  "environment",
+  "schema",
+  "table",
+  "columns",
+  "operations",
+  "topic",
+  "event_type",
+];
 const SCHEDULE_NAME_PATTERN = /^[a-z][a-z0-9_-]{0,62}$/u;
 const CURSOR_PATTERN = /^[A-Za-z0-9._|:=+/-]{1,200}$/u;
 const HEADER_NAME_PATTERN = /^[A-Za-z][A-Za-z0-9-]{0,63}$/u;
@@ -225,11 +280,79 @@ export function parseDatabaseWebhookId(value: unknown): string {
   return value;
 }
 
+export function parseDatabaseWatchId(value: unknown): string {
+  if (!isDatabaseWatchTriggerName(value)) throw new TypeError("Invalid database watch id");
+  return value;
+}
+
 export function parseDatabaseDeliveryId(value: unknown): string {
   if (!matches(value, DELIVERY_ID_PATTERN)) throw new TypeError("Invalid database delivery id");
   return value;
 }
 
+/** The trigger names of the watch service; migrations may not create them, so the watch count stays exact. */
+export function isDatabaseWatchTriggerName(value: unknown): value is string {
+  return matches(value, DATABASE_WATCH_ID_PATTERN);
+}
+
+/** Identifiers are plain SQL names: no quotes, dots or spaces; the caller quotes them. */
+export function isDatabaseWatchIdentifier(value: unknown): value is string {
+  return matches(value, DATABASE_WATCH_IDENTIFIER_PATTERN);
+}
+
+/** Reserved platform schemas stay out of reach; the check ignores case like PostgreSQL does. */
+export function isDatabaseWatchSchema(value: unknown): value is string {
+  if (!isDatabaseWatchIdentifier(value)) return false;
+  const lower = value.toLowerCase();
+  return !lower.startsWith("pg_") && !DATABASE_WATCH_FORBIDDEN_SCHEMAS.includes(lower);
+}
+
+/**
+ * The topic of a watched table, the same rule pgcf.capture applies in SQL: lower-case, every
+ * character outside [a-z0-9_] becomes '_', 't_' before a name that does not start with a letter,
+ * at most 48 characters. Lower-casing is per character, like PostgreSQL's simple lower() of the
+ * builtin C.UTF-8 locale that PGCF's initdb uses (SELECT lower(U&'\0130'), lower(U&'\212A') answers 'i' and 'k').
+ */
+export function dataEventTopic(tableName: string): string {
+  const mapped = Array.from(tableName, (character) => {
+    const lower = Array.from(character.toLowerCase())[0] ?? "_";
+    return /^[a-z0-9_]$/u.test(lower) ? lower : "_";
+  }).join("");
+  const topic = /^[a-z]/u.test(mapped) ? mapped : `t_${mapped}`;
+  return topic.slice(0, 48);
+}
+
+export function parseDatabaseWatchCreateRequest(value: unknown): DatabaseWatchRequest {
+  if (
+    !record(value) ||
+    !onlyKeys(value, ["schema", "table", "columns", "operations"]) ||
+    !isDatabaseWatchIdentifier(value["table"]) ||
+    !Array.isArray(value["columns"]) ||
+    value["columns"].length < 1 ||
+    value["columns"].length > DATABASE_WATCH_MAX_COLUMNS ||
+    !value["columns"].every(isDatabaseWatchIdentifier) ||
+    new Set(value["columns"]).size !== value["columns"].length
+  )
+    throw new TypeError("Invalid database watch request");
+  return {
+    ...parseDatabaseWatchTarget({ schema: value["schema"], table: value["table"] }),
+    columns: value["columns"] as string[],
+    operations: parseWatchOperations(value["operations"]),
+  };
+}
+
+export function parseDatabaseWatchTarget(value: unknown): DatabaseWatchTarget {
+  if (
+    !record(value) ||
+    !onlyKeys(value, ["schema", "table"]) ||
+    !isDatabaseWatchIdentifier(value["table"])
+  )
+    throw new TypeError("Invalid database watch target");
+  const schema = value["schema"] === undefined ? DATABASE_WATCH_DEFAULT_SCHEMA : value["schema"];
+  if (!isDatabaseWatchSchema(schema)) throw new TypeError("Invalid database watch target");
+  return { schema, table: value["table"] };
+}
+
 export function parseDatabaseScheduleName(value: unknown): string {
   if (!matches(value, SCHEDULE_NAME_PATTERN)) throw new TypeError("Invalid database schedule name");
   return value;
@@ -307,6 +430,41 @@ export function assertDatabaseWebhook(value: unknown): asserts value is Database
   assertWebhookFields(value);
 }
 
+export function assertDatabaseWatch(value: unknown): asserts value is DatabaseWatch {
+  if (
+    !record(value) ||
+    !exact(value, DATABASE_WATCH_KEYS) ||
+    !matches(value["id"], DATABASE_WATCH_ID_PATTERN) ||
+    !oneOf(["dev", "prod"] as const, value["environment"]) ||
+    !isDatabaseWatchSchema(value["schema"]) ||
+    !isDatabaseWatchIdentifier(value["table"]) ||
+    !Array.isArray(value["columns"]) ||
+    value["columns"].length < 1 ||
+    value["columns"].length > DATABASE_WATCH_MAX_COLUMNS ||
+    !value["columns"].every(isDatabaseWatchIdentifier) ||
+    !isCanonicalOperations(value["operations"]) ||
+    value["topic"] !== dataEventTopic(value["table"]) ||
+    value["event_type"] !== `data.${value["topic"]}`
+  )
+    throw new TypeError("Invalid database watch");
+}
+
+export function assertDatabaseWatchPage(value: unknown): asserts value is DatabaseWatchPage {
+  if (!record(value) || !exact(value, ["items"]) || !pageItems(value["items"]))
+    throw new TypeError("Invalid database watch page");
+  for (const item of value["items"]) assertDatabaseWatch(item);
+}
+
+export function assertDatabaseWatchDeleted(value: unknown): asserts value is DatabaseWatchDeleted {
+  if (
+    !record(value) ||
+    !exact(value, ["id", "deleted"]) ||
+    !matches(value["id"], DATABASE_WATCH_ID_PATTERN) ||
+    value["deleted"] !== true
+  )
+    throw new TypeError("Invalid database watch deletion");
+}
+
 export function assertDatabaseWebhookCreated(
   value: unknown,
 ): asserts value is DatabaseWebhookCreated {
@@ -358,7 +516,7 @@ export function assertDatabaseWebhookDelivery(
     ]) ||
     !matches(value["id"], DELIVERY_ID_PATTERN) ||
     !matches(value["event_id"], EVENT_ID_PATTERN) ||
-    !oneOf(DATABASE_WEBHOOK_EVENT_TYPES, value["event_type"]) ||
+    !isDeliveredEventType(value["event_type"]) ||
     !matches(value["webhook_id"], WEBHOOK_ID_PATTERN) ||
     !oneOf(["pending", "delivered", "dead_lettered"] as const, value["state"]) ||
     !nonNegativeInteger(value["attempts"]) ||
@@ -538,7 +696,7 @@ function assertWebhookFields(value: Record<string, unknown>): void {
     !Array.isArray(value["event_types"]) ||
     value["event_types"].length < 1 ||
     value["event_types"].length > DATABASE_WEBHOOK_MAX_EVENT_TYPES ||
-    !value["event_types"].every((type) => oneOf(DATABASE_WEBHOOK_EVENT_TYPES, type)) ||
+    !value["event_types"].every(isDatabaseWebhookEventPattern) ||
     !Array.isArray(value["header_names"]) ||
     value["header_names"].length > DATABASE_WEBHOOK_MAX_HEADERS ||
     !value["header_names"].every((name) => matches(name, HEADER_NAME_PATTERN)) ||
@@ -561,16 +719,55 @@ function isHttpsUrl(value: unknown): value is string {
   }
 }
 
-function parseEventTypes(value: unknown): readonly DatabaseWebhookEventType[] {
+export function isDatabaseWebhookEventPattern(
+  value: unknown,
+): value is DatabaseWebhookEventPattern {
+  return oneOf(DATABASE_WEBHOOK_EVENT_TYPES, value) || matches(value, DATA_SUBSCRIPTION_PATTERN);
+}
+
+/** A delivery names one concrete event: a platform type or one data topic, never a wildcard. */
+function isDeliveredEventType(
+  value: unknown,
+): value is DatabaseWebhookEventType | DatabaseDataEventType {
+  return oneOf(DATABASE_WEBHOOK_EVENT_TYPES, value) || matches(value, DATA_EVENT_TYPE_PATTERN);
+}
+
+/** Event types of one webhook: 1 to 16 distinct patterns; a bare `*` is not among them. */
+export function isDatabaseWebhookEventTypes(
+  value: unknown,
+): value is readonly DatabaseWebhookEventPattern[] {
+  return (
+    Array.isArray(value) &&
+    value.length >= 1 &&
+    value.length <= DATABASE_WEBHOOK_MAX_EVENT_TYPES &&
+    value.every(isDatabaseWebhookEventPattern) &&
+    new Set(value).size === value.length
+  );
+}
+
+function parseEventTypes(value: unknown): readonly DatabaseWebhookEventPattern[] {
+  if (!isDatabaseWebhookEventTypes(value))
+    throw new TypeError("Invalid database webhook event types");
+  return value;
+}
+
+function parseWatchOperations(value: unknown): readonly DatabaseWatchOperation[] {
+  if (value === undefined) return DATABASE_WATCH_OPERATIONS;
   if (
     !Array.isArray(value) ||
     value.length < 1 ||
-    value.length > DATABASE_WEBHOOK_MAX_EVENT_TYPES ||
-    !value.every((type) => oneOf(DATABASE_WEBHOOK_EVENT_TYPES, type)) ||
+    !value.every((operation) => oneOf(DATABASE_WATCH_OPERATIONS, operation)) ||
     new Set(value).size !== value.length
   )
-    throw new TypeError("Invalid database webhook event types");
-  return value as DatabaseWebhookEventType[];
+    throw new TypeError("Invalid database watch request");
+  return DATABASE_WATCH_OPERATIONS.filter((operation) => value.includes(operation));
+}
+
+/** Operations are stored and asserted in the canonical order insert, update, delete. */
+function isCanonicalOperations(value: unknown): value is DatabaseWatchOperation[] {
+  if (!Array.isArray(value) || value.length < 1) return false;
+  const canonical = DATABASE_WATCH_OPERATIONS.filter((operation) => value.includes(operation));
+  return canonical.length === value.length && canonical.every((op, index) => op === value[index]);
 }
 
 function parseHeaders(value: unknown): Record<string, string> {

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

@@ -1,4 +1,9 @@
+import { isDatabaseWatchTriggerName } from "./database-events.js";
 import { DatabaseMigrationAdmissionError } from "./database-migration-errors.js";
+import {
+  readMigrationCaptureTrigger,
+  type DatabaseMigrationCaptureTrigger,
+} from "./database-migration-capture.js";
 import {
   readMigrationSql,
   rejectMigrationSqlReferences,
@@ -11,6 +16,7 @@ import {
 
 export { DatabaseMigrationAdmissionError } from "./database-migration-errors.js";
 export type { DatabaseMigrationAdmissionReason } from "./database-migration-errors.js";
+export type { DatabaseMigrationCaptureTrigger } from "./database-migration-capture.js";
 export type { DatabaseMigrationRlsTarget } from "./database-migration-policies.js";
 
 const MAX_MIGRATION_COUNT = 128;
@@ -68,6 +74,16 @@ export function admitExpandOnlyMigrations(
       throw new DatabaseMigrationAdmissionError("invalid");
     }
     const statements = parseDatabaseMigrationStatements(sql);
+    // The watch service alone creates triggers under its reserved names, so the watch count stays exact.
+    if (
+      statements.some(
+        (statement) =>
+          statement.captureTrigger !== undefined &&
+          isDatabaseWatchTriggerName(statement.captureTrigger.trigger),
+      )
+    ) {
+      throw new DatabaseMigrationAdmissionError("unsupported");
+    }
     statementCount += statements.length;
     return Object.freeze({ path: migration.path, statementCount: statements.length });
   });
@@ -77,6 +93,7 @@ export function admitExpandOnlyMigrations(
 export interface DatabaseMigrationStatement {
   readonly sql: string;
   readonly rlsTarget?: DatabaseMigrationRlsTarget;
+  readonly captureTrigger?: DatabaseMigrationCaptureTrigger;
 }
 
 export function parseDatabaseMigrationStatements(
@@ -94,6 +111,11 @@ export function parseDatabaseMigrationStatements(
   if (statements.length === 0) throw new DatabaseMigrationAdmissionError("invalid");
   return Object.freeze(
     statements.map((statement) => {
+      const capture = readMigrationCaptureTrigger(statement.tokens);
+      if (capture !== undefined) {
+        rejectMigrationSqlReferences(capture.header);
+        return Object.freeze({ sql: statement.sql, captureTrigger: capture.target });
+      }
       // Provider references are forbidden throughout executable policy SQL, while
       // the native helper exception is narrowed by the policy reader below.
       rejectMigrationSqlReferences(statement.tokens, true);

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/problem-policy.ts

@@ -192,6 +192,41 @@ 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",
+  },
   project_notes_conflict: {
     status: 409,
     retryable: false,
@@ -502,7 +537,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.45",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -23,6 +23,7 @@ export {
   createOrganization,
   createProject,
   createProjectDatabaseAccess,
+  createProjectDatabaseWatch,
   createProjectDatabaseWebhook,
   createProjectDataChange,
   createProjectDevAccessTicket,
@@ -35,6 +36,7 @@ export {
   deletePaidProjectDomain,
   deleteProject,
   deleteProjectDatabaseSchedule,
+  deleteProjectDatabaseWatch,
   deleteProjectDatabaseWebhook,
   detachProjectMailDomainBinding,
   diffManagedSource,
@@ -91,6 +93,7 @@ export {
   listProjectDatabaseAccess,
   listProjectDatabaseScheduleRuns,
   listProjectDatabaseSchedules,
+  listProjectDatabaseWatches,
   listProjectDatabaseWebhookDeliveries,
   listProjectDatabaseWebhooks,
   listProjects,
@@ -271,6 +274,11 @@ export type {
   CreateProjectDatabaseAccessErrors,
   CreateProjectDatabaseAccessResponse,
   CreateProjectDatabaseAccessResponses,
+  CreateProjectDatabaseWatchData,
+  CreateProjectDatabaseWatchError,
+  CreateProjectDatabaseWatchErrors,
+  CreateProjectDatabaseWatchResponse,
+  CreateProjectDatabaseWatchResponses,
   CreateProjectDatabaseWebhookData,
   CreateProjectDatabaseWebhookError,
   CreateProjectDatabaseWebhookErrors,
@@ -325,6 +333,11 @@ export type {
   DatabaseScheduleRunAccepted,
   DatabaseScheduleRunPage,
   DatabaseScheduleSetRequest,
+  DatabaseWatch,
+  DatabaseWatchCreateRequest,
+  DatabaseWatchDeleted,
+  DatabaseWatchId,
+  DatabaseWatchPage,
   DatabaseWebhook,
   DatabaseWebhookCreated,
   DatabaseWebhookCreateRequest,
@@ -332,6 +345,8 @@ export type {
   DatabaseWebhookDelivery,
   DatabaseWebhookDeliveryId,
   DatabaseWebhookDeliveryPage,
+  DatabaseWebhookEventPattern,
+  DatabaseWebhookEventPatternWritable,
   DatabaseWebhookEventType,
   DatabaseWebhookId,
   DatabaseWebhookPage,
@@ -364,6 +379,11 @@ export type {
   DeleteProjectDatabaseScheduleErrors,
   DeleteProjectDatabaseScheduleResponse,
   DeleteProjectDatabaseScheduleResponses,
+  DeleteProjectDatabaseWatchData,
+  DeleteProjectDatabaseWatchError,
+  DeleteProjectDatabaseWatchErrors,
+  DeleteProjectDatabaseWatchResponse,
+  DeleteProjectDatabaseWatchResponses,
   DeleteProjectDatabaseWebhookData,
   DeleteProjectDatabaseWebhookError,
   DeleteProjectDatabaseWebhookErrors,
@@ -685,6 +705,11 @@ export type {
   ListProjectDatabaseSchedulesErrors,
   ListProjectDatabaseSchedulesResponse,
   ListProjectDatabaseSchedulesResponses,
+  ListProjectDatabaseWatchesData,
+  ListProjectDatabaseWatchesError,
+  ListProjectDatabaseWatchesErrors,
+  ListProjectDatabaseWatchesResponse,
+  ListProjectDatabaseWatchesResponses,
   ListProjectDatabaseWebhookDeliveriesData,
   ListProjectDatabaseWebhookDeliveriesError,
   ListProjectDatabaseWebhookDeliveriesErrors,