@amerged/ohmyhost-cli 0.1.41 → 0.1.43

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

@@ -20,6 +20,36 @@ import {
   type ProjectDatabaseWriteReceipt,
 } from "@ohmyhost/contracts/database-access";
 import { assertDatabaseCompute, type DatabaseCompute } from "@ohmyhost/contracts/database-compute";
+import {
+  assertDatabaseExecutionUsagePage,
+  assertDatabaseSchedule,
+  assertDatabaseSchedulePage,
+  assertDatabaseScheduleDeleted,
+  assertDatabaseScheduleRunAccepted,
+  assertDatabaseScheduleRunPage,
+  assertDatabaseWebhook,
+  assertDatabaseWebhookCreated,
+  assertDatabaseWebhookDeleted,
+  assertDatabaseWebhookDeliveryPage,
+  assertDatabaseWebhookPage,
+  assertDatabaseWebhookReplayAccepted,
+  assertDatabaseWebhookTest,
+  type DatabaseExecutionUsagePage,
+  type DatabaseSchedule,
+  type DatabaseScheduleDeleted,
+  type DatabaseSchedulePage,
+  type DatabaseScheduleRunAccepted,
+  type DatabaseScheduleRunPage,
+  type DatabaseScheduleSetRequest,
+  type DatabaseWebhook,
+  type DatabaseWebhookCreated,
+  type DatabaseWebhookDeleted,
+  type DatabaseWebhookDeliveryPage,
+  type DatabaseWebhookEventType,
+  type DatabaseWebhookPage,
+  type DatabaseWebhookReplayAccepted,
+  type DatabaseWebhookTestResult,
+} from "@ohmyhost/contracts/database-events";
 import type { DatabaseComputeSelection } from "@ohmyhost/contracts/database-sizes";
 import {
   assertProjectContext,
@@ -117,6 +147,20 @@ import {
   createProjectDatabaseAccess,
   listProjectDatabaseAccess,
   revokeProjectDatabaseAccess,
+  createProjectDatabaseWebhook,
+  listProjectDatabaseWebhooks,
+  getProjectDatabaseWebhook,
+  deleteProjectDatabaseWebhook,
+  testProjectDatabaseWebhook,
+  listProjectDatabaseWebhookDeliveries,
+  replayProjectDatabaseWebhookDelivery,
+  setProjectDatabaseSchedule,
+  listProjectDatabaseSchedules,
+  getProjectDatabaseSchedule,
+  deleteProjectDatabaseSchedule,
+  listProjectDatabaseScheduleRuns,
+  runProjectDatabaseSchedule,
+  getProjectDatabaseExecutionUsage,
   reconcileOperation,
   streamOperationEvents,
   type DeploymentPlan,
@@ -279,6 +323,85 @@ export interface ProductApi {
     readonly projectId: string;
     readonly accessId: string;
   }): Promise<ProjectDatabaseAccess>;
+  createProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly idempotencyKey: string;
+    readonly url: string;
+    readonly eventTypes: readonly DatabaseWebhookEventType[];
+    readonly headers: Readonly<Record<string, string>>;
+  }): Promise<DatabaseWebhookCreated>;
+  listProjectDatabaseWebhooks(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+  }): Promise<DatabaseWebhookPage>;
+  getProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId: string;
+  }): Promise<DatabaseWebhook>;
+  deleteProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId: string;
+  }): Promise<DatabaseWebhookDeleted>;
+  testProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId: string;
+  }): Promise<DatabaseWebhookTestResult>;
+  listProjectDatabaseWebhookDeliveries(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId?: string;
+    readonly limit?: number;
+    readonly cursor?: string;
+  }): Promise<DatabaseWebhookDeliveryPage>;
+  replayProjectDatabaseWebhookDelivery(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly deliveryId: string;
+  }): Promise<DatabaseWebhookReplayAccepted>;
+  setProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+    readonly request: DatabaseScheduleSetRequest;
+  }): Promise<DatabaseSchedule>;
+  listProjectDatabaseSchedules(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+  }): Promise<DatabaseSchedulePage>;
+  getProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+  }): Promise<DatabaseSchedule>;
+  deleteProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+  }): Promise<DatabaseScheduleDeleted>;
+  listProjectDatabaseScheduleRuns(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+    readonly limit?: number;
+  }): Promise<DatabaseScheduleRunPage>;
+  runProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+  }): Promise<DatabaseScheduleRunAccepted>;
+  getProjectDatabaseExecutionUsage(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly from: string;
+    readonly to: string;
+    readonly granularity: "hour" | "day";
+    readonly limit?: number;
+    readonly cursor?: string;
+  }): Promise<DatabaseExecutionUsagePage>;
   planPaidDomain(input: {
     readonly projectId: string;
     readonly hostname: string;
@@ -441,6 +564,11 @@ export interface ProductApi {
   managedMail?(input: ManagedMailCommand): Promise<unknown>;
 }
 
+/** A webhook answer that names another environment, webhook or delivery than the request did. */
+const WEBHOOK_SCOPE_MISMATCH = "Webhook response scope mismatch";
+/** A schedule answer that names another environment or schedule than the request did. */
+const SCHEDULE_SCOPE_MISMATCH = "Schedule response scope mismatch";
+
 export class GeneratedSdkProductApi implements ProductApi {
   readonly #client: OhMyHostClient;
   public readonly managedSource: ManagedSourceApi;
@@ -761,6 +889,241 @@ export class GeneratedSdkProductApi implements ProductApi {
     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],
+  ): Promise<DatabaseWebhookCreated> {
+    const value = await createProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        "Idempotency-Key": input.idempotencyKey,
+        databaseWebhookCreateRequest: {
+          url: input.url,
+          event_types: [...input.eventTypes],
+          headers: { ...input.headers },
+        },
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookCreated(value);
+    if (value.environment !== input.environment) throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseWebhooks(
+    input: Parameters<ProductApi["listProjectDatabaseWebhooks"]>[0],
+  ): Promise<DatabaseWebhookPage> {
+    const value = await listProjectDatabaseWebhooks(
+      { project_id: input.projectId, environment: input.environment },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookPage(value);
+    if (value.items.some((item) => item.environment !== input.environment))
+      throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async getProjectDatabaseWebhook(
+    input: Parameters<ProductApi["getProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhook> {
+    const value = await getProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        webhook_id: input.webhookId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhook(value);
+    if (value.id !== input.webhookId || value.environment !== input.environment)
+      throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async deleteProjectDatabaseWebhook(
+    input: Parameters<ProductApi["deleteProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhookDeleted> {
+    const value = await deleteProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        webhook_id: input.webhookId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookDeleted(value);
+    if (value.id !== input.webhookId) throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async testProjectDatabaseWebhook(
+    input: Parameters<ProductApi["testProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhookTestResult> {
+    const value = await testProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        webhook_id: input.webhookId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookTest(value);
+    return value;
+  }
+
+  public async listProjectDatabaseWebhookDeliveries(
+    input: Parameters<ProductApi["listProjectDatabaseWebhookDeliveries"]>[0],
+  ): Promise<DatabaseWebhookDeliveryPage> {
+    const value = await listProjectDatabaseWebhookDeliveries(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        ...(input.webhookId === undefined ? {} : { webhook_id: input.webhookId }),
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookDeliveryPage(value);
+    if (
+      input.webhookId !== undefined &&
+      value.items.some((item) => item.webhook_id !== input.webhookId)
+    )
+      throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async replayProjectDatabaseWebhookDelivery(
+    input: Parameters<ProductApi["replayProjectDatabaseWebhookDelivery"]>[0],
+  ): Promise<DatabaseWebhookReplayAccepted> {
+    const value = await replayProjectDatabaseWebhookDelivery(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        delivery_id: input.deliveryId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookReplayAccepted(value);
+    if (value.delivery_id !== input.deliveryId) throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  /** A schedule runs the statements as the application's runtime role; the request confirms it. */
+  public async setProjectDatabaseSchedule(
+    input: Parameters<ProductApi["setProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseSchedule> {
+    const request = input.request;
+    const value = await setProjectDatabaseSchedule(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        name: input.name,
+        databaseScheduleSetRequest: {
+          ...(request.cron === null ? {} : { cron: request.cron }),
+          ...(request.every_seconds === null ? {} : { every_seconds: request.every_seconds }),
+          statements: [...request.statements],
+          timeout_ms: request.timeout_ms,
+          enabled: request.enabled,
+          confirm: true,
+        },
+      },
+      { client: this.#client },
+    );
+    assertDatabaseSchedule(value);
+    if (value.name !== input.name || value.environment !== input.environment)
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseSchedules(
+    input: Parameters<ProductApi["listProjectDatabaseSchedules"]>[0],
+  ): Promise<DatabaseSchedulePage> {
+    const value = await listProjectDatabaseSchedules(
+      { project_id: input.projectId, environment: input.environment },
+      { client: this.#client },
+    );
+    assertDatabaseSchedulePage(value);
+    if (value.items.some((item) => item.environment !== input.environment))
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async getProjectDatabaseSchedule(
+    input: Parameters<ProductApi["getProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseSchedule> {
+    const value = await getProjectDatabaseSchedule(
+      { project_id: input.projectId, environment: input.environment, name: input.name },
+      { client: this.#client },
+    );
+    assertDatabaseSchedule(value);
+    if (value.name !== input.name || value.environment !== input.environment)
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async deleteProjectDatabaseSchedule(
+    input: Parameters<ProductApi["deleteProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseScheduleDeleted> {
+    const value = await deleteProjectDatabaseSchedule(
+      { project_id: input.projectId, environment: input.environment, name: input.name },
+      { client: this.#client },
+    );
+    assertDatabaseScheduleDeleted(value);
+    if (value.name !== input.name) throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseScheduleRuns(
+    input: Parameters<ProductApi["listProjectDatabaseScheduleRuns"]>[0],
+  ): Promise<DatabaseScheduleRunPage> {
+    const value = await listProjectDatabaseScheduleRuns(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        name: input.name,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+      },
+      { client: this.#client },
+    );
+    assertDatabaseScheduleRunPage(value);
+    if (value.items.some((item) => item.schedule !== input.name))
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async runProjectDatabaseSchedule(
+    input: Parameters<ProductApi["runProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseScheduleRunAccepted> {
+    const value = await runProjectDatabaseSchedule(
+      { project_id: input.projectId, environment: input.environment, name: input.name },
+      { client: this.#client },
+    );
+    assertDatabaseScheduleRunAccepted(value);
+    if (value.schedule !== input.name) throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async getProjectDatabaseExecutionUsage(
+    input: Parameters<ProductApi["getProjectDatabaseExecutionUsage"]>[0],
+  ): Promise<DatabaseExecutionUsagePage> {
+    const value = await getProjectDatabaseExecutionUsage(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        from: input.from,
+        to: input.to,
+        granularity: input.granularity,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+      },
+      { client: this.#client },
+    );
+    assertDatabaseExecutionUsagePage(value);
+    return value;
+  }
+
   public async planPaidDomain(input: {
     readonly projectId: string;
     readonly hostname: string;

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

@@ -9,21 +9,17 @@ export const runLocalPsql = async (input: {
   readonly user: string;
   readonly password: string;
   readonly database: string;
-  readonly websocketUrl?: string;
+  readonly websocketUrl: string;
   readonly signal: AbortSignal;
 }): Promise<number> => {
   input.signal.throwIfAborted();
-  if (input.websocketUrl !== undefined && input.websocketUrl !== `wss://${input.host}/`)
-    throw new Error("Invalid PGCF transport");
-  const bridge =
-    input.websocketUrl === undefined
-      ? null
-      : await startBridge({
-          endpoint: input.websocketUrl,
-          database: input.database,
-          user: input.user,
-          port: 0,
-        });
+  if (input.websocketUrl !== `wss://${input.host}/`) throw new Error("Invalid PGCF transport");
+  const bridge = await startBridge({
+    endpoint: input.websocketUrl,
+    database: input.database,
+    user: input.user,
+    port: 0,
+  });
   try {
     input.signal.throwIfAborted();
     // A caller's libpq service/hostaddr settings must not redirect this temporary credential.
@@ -31,26 +27,18 @@ export const runLocalPsql = async (input: {
       Object.entries(process.env).filter(([key]) => !/^PG[A-Z_]+$/iu.test(key)),
     );
     return await new Promise<number>((resolve, reject) => {
-      const child = spawn(
-        "psql",
-        ["-h", bridge?.host ?? input.host, "-U", input.user, "-d", input.database],
-        {
-          stdio: "inherit",
-          signal: input.signal,
-          env: {
-            ...environment,
-            PGPASSWORD: input.password,
-            PGSSLMODE: bridge ? "disable" : "require",
-            ...(bridge
-              ? {
-                  PGPORT: String(bridge.port),
-                  PGCHANNELBINDING: "disable",
-                  PGGSSENCMODE: "disable",
-                }
-              : {}),
-          },
+      const child = spawn("psql", ["-h", bridge.host, "-U", input.user, "-d", input.database], {
+        stdio: "inherit",
+        signal: input.signal,
+        env: {
+          ...environment,
+          PGPASSWORD: input.password,
+          PGSSLMODE: "disable",
+          PGPORT: String(bridge.port),
+          PGCHANNELBINDING: "disable",
+          PGGSSENCMODE: "disable",
         },
-      );
+      });
       child.once("error", (error: NodeJS.ErrnoException) => {
         reject(error.code === "ENOENT" ? new PsqlUnavailableError() : error);
       });
@@ -59,6 +47,6 @@ export const runLocalPsql = async (input: {
       });
     });
   } finally {
-    await bridge?.close();
+    await bridge.close();
   }
 };

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

@@ -23,7 +23,6 @@ import type {
   ProjectCreditBudget,
 } from "@ohmyhost/sdk-ts";
 import { isSaasCnameTarget, type SaasCnameTarget } from "@ohmyhost/contracts/platform-origins";
-import { assertPublishedCreditRateCards } from "@ohmyhost/contracts/credit-pricing";
 import {
   publicOperationFailure,
   publicOperationReconciliation,
@@ -554,14 +553,7 @@ export function parseOrganizationCredits(value: unknown): OrganizationCredits {
     "reserved_micros",
     "grace_started_at",
     "grace_expires_at",
-    "active_meters",
-    "rate_cards",
   ]);
-  try {
-    assertPublishedCreditRateCards(input["rate_cards"]);
-  } catch {
-    throw new ResponseContractError();
-  }
   const graceStart = input["grace_started_at"],
     graceEnd = input["grace_expires_at"];
   if (
@@ -576,11 +568,7 @@ export function parseOrganizationCredits(value: unknown): OrganizationCredits {
   if (
     !isUlid(input["organization_id"]) ||
     input["unit"] !== "microcredits" ||
-    !isIsoInstant(input["as_of"]) ||
-    !Array.isArray(input["active_meters"]) ||
-    input["active_meters"].some(
-      (m: unknown) => typeof m !== "string" || !/^[a-z0-9_.-]{1,128}$/u.test(m),
-    )
+    !isIsoInstant(input["as_of"])
   )
     throw new ResponseContractError();
   for (const field of ["available_micros", "reserved_micros"]) {

package/src/packages/contracts/package.json

@@ -127,6 +127,11 @@
       "types": "./dist/database-access.d.ts",
       "import": "./dist/database-access.js"
     },
+    "./database-events": {
+      "source": "./src/database-events.ts",
+      "types": "./dist/database-events.d.ts",
+      "import": "./dist/database-events.js"
+    },
     "./functions": {
       "source": "./src/functions.ts",
       "types": "./dist/functions.d.ts",

package/src/packages/contracts/src/credit-pricing.ts

@@ -116,96 +116,6 @@ export function assertOrganizationCreditUsage(
   }
 }
 
-export interface PublishedCreditRateCard {
-  readonly id: string;
-  readonly currency: "USD";
-  readonly published_at: string;
-  readonly effective_from: string;
-  readonly rates: readonly {
-    readonly meter: string;
-    readonly unit: string;
-    readonly units_per_charge: string;
-    readonly provider_cost_micros: string | null;
-    readonly credit_micros: string;
-  }[];
-}
-
-/** Shared wire validation only; clients never recompute accounting decisions. */
-export function assertPublishedCreditRateCards(
-  value: unknown,
-): asserts value is readonly PublishedCreditRateCard[] {
-  if (!Array.isArray(value) || value.length > 4) throw new TypeError("Invalid published prices");
-  const ids = new Set<string>();
-  for (const input of value) {
-    if (
-      !input ||
-      typeof input !== "object" ||
-      Array.isArray(input) ||
-      Object.keys(input).sort().join() !== "currency,effective_from,id,published_at,rates"
-    )
-      throw new TypeError("Invalid published price fields");
-    const card = input as Record<string, unknown>;
-    if (
-      typeof card["id"] !== "string" ||
-      !/^[a-z0-9_.-]{1,128}$/u.test(card["id"]) ||
-      ids.has(card["id"]) ||
-      card["currency"] !== "USD"
-    )
-      throw new TypeError("Invalid price identity");
-    ids.add(card["id"]);
-    for (const key of ["published_at", "effective_from"]) {
-      const date = card[key];
-      if (
-        typeof date !== "string" ||
-        !Number.isFinite(Date.parse(date)) ||
-        new Date(date).toISOString() !== date
-      )
-        throw new TypeError("Invalid price dates");
-    }
-    if (
-      String(card["published_at"]) > String(card["effective_from"]) ||
-      !Array.isArray(card["rates"]) ||
-      card["rates"].length < 1 ||
-      card["rates"].length > 32
-    )
-      throw new TypeError("Invalid price publication");
-    const meters = new Set<string>();
-    for (const item of card["rates"]) {
-      if (
-        !item ||
-        typeof item !== "object" ||
-        Array.isArray(item) ||
-        Object.keys(item).sort().join() !==
-          "credit_micros,meter,provider_cost_micros,unit,units_per_charge"
-      )
-        throw new TypeError("Invalid rate fields");
-      const rate = item as Record<string, unknown>;
-      for (const key of ["meter", "unit"])
-        if (typeof rate[key] !== "string" || !/^[a-z0-9_.-]{1,128}$/u.test(String(rate[key])))
-          throw new TypeError("Invalid rate unit");
-      const identity = String(rate["meter"]) + "/" + String(rate["unit"]);
-      if (meters.has(identity)) throw new TypeError("Duplicate rate");
-      meters.add(identity);
-      for (const key of ["units_per_charge", "provider_cost_micros", "credit_micros"]) {
-        const amount = rate[key];
-        if (
-          key === "provider_cost_micros" &&
-          amount === null &&
-          rate["meter"] === "pgcf.memory.active"
-        )
-          continue;
-        if (
-          typeof amount !== "string" ||
-          !/^(0|[1-9][0-9]{0,18})$/u.test(amount) ||
-          BigInt(amount) > 9223372036854775807n ||
-          (key === "units_per_charge" && amount === "0")
-        )
-          throw new TypeError("Invalid rate amount");
-      }
-    }
-  }
-}
-
 /** Effective feature access and the credit account: the monthly and one-time credit and what the open reservations hold. */
 export function assertOrganizationAccount(value: unknown): void {
   if (