@amerged/ohmyhost-cli 0.1.45 → 0.1.46

package/dist/index.js

@@ -34,6 +34,7 @@ import {
   StderrDeviceAuthorizationPresenter,
   TokenRefreshRejectedError,
   UserTokenFileError,
+  assertDatabaseTableAnswer,
   assertVerifiedLogin,
   chooseLinkedProject,
   chooseWorkspace,
@@ -100,7 +101,7 @@ import {
   selectWorkspace,
   verifiedUserId,
   workspaceOf
-} from "./chunk-C6KEAOJP.js";
+} from "./chunk-A4ZYW4XW.js";
 import {
   CredentialStoreIntegrityError,
   CredentialStoreUnavailableError,
@@ -287,6 +288,7 @@ export {
   StderrDeviceAuthorizationPresenter,
   TokenRefreshRejectedError,
   UserTokenFileError,
+  assertDatabaseTableAnswer,
   assertVerifiedLogin,
   chooseLinkedProject,
   chooseWorkspace,

package/package.json

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

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

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

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

@@ -68,7 +68,15 @@ import {
   type CurrentCredential,
   type StoredCredential,
 } from "./credential-store.js";
-import type { ProductApi } from "./product-api.js";
+import type {
+  DatabaseTableColumnInput,
+  DatabaseTableCreateInput,
+  ProductApi,
+} from "./product-api.js";
+import {
+  parseDatabaseTableCreateRequest,
+  type DatabaseTableColumn,
+} from "@ohmyhost/contracts/database-tables";
 import {
   defaultProfileName,
   isProfileUserId,
@@ -425,6 +433,8 @@ const HELP_USAGE = Object.freeze({
     "ohmyhost database watch list --project ULID [--environment dev|prod] --json (dev when omitted; a sleeping database wakes)",
   "database watch delete":
     "ohmyhost database watch delete --project ULID --environment dev|prod --watch ID --idempotency-key KEY --yes --json",
+  "database table create":
+    "ohmyhost database table create --project ULID --environment dev|prod --table NAME --columns-file PATH [--primary-key COL[,COL]] --idempotency-key KEY --yes --json (the table is created in the public schema as the migration role, with the same access as migration tables, so a database watch can attach later; the columns file is a UTF-8 JSON array of 1 to 64 column objects, at most 64 KiB, each with name, type and optional nullable, identity and default; types: text, integer, bigint, boolean, numeric, double precision, timestamptz, date, uuid, jsonb; identity needs integer or bigint; default now needs timestamptz and default uuid needs uuid; identical repeats answer created false; at most 100 tables, 64 columns per table)",
   "database webhook create":
     "ohmyhost database webhook create --project ULID --environment dev|prod --url HTTPS_URL --event-types TYPE[,TYPE] [--headers-file PATH] --idempotency-key KEY --yes --json (the signing secret is shown once in this answer; types: database.created, database.ready, database.woke, database.slept, database.suspended, database.resized, database.deleted, data.<topic> for the rows of one watched table printed by database watch create, or data.* for every watched table; a bare * is not accepted and does not include data events; the headers file is a UTF-8 JSON object of at most 8 KiB)",
   "database webhook list":
@@ -665,6 +675,9 @@ const SCHEDULE_STATEMENTS_FILE_INVALID_ACTION =
 const SCHEDULE_INVALID_ACTION =
   "Check the schedule request: --cron takes five fields in UTC (9 to 120 characters), or --every-seconds takes 60 to 2678400, never both; --timeout-ms takes 1000 to 30000; the statements file must hold 1 to 20 non-blank SQL strings of at most 16 KiB each and 64 KiB in total. Nothing was saved; fix it and run the command again.";
 
+const COLUMNS_FILE_INVALID_ACTION =
+  "Put one JSON array of 1 to 64 column objects in the file named by --columns-file: UTF-8, at most 64 KiB, each with a lower-case name, a type (text, integer, bigint, boolean, numeric, double precision, timestamptz, date, uuid or jsonb) and optional nullable, identity (integer or bigint only) and default (now for timestamptz, uuid for uuid). Each --primary-key column must be one of them, at most 8 names. Nothing was created; fix the file or the flags and run the command again.";
+
 const STATEMENT_FILE_INVALID_ACTION =
   "Put one INSERT, UPDATE or DELETE statement that starts with that keyword (no leading comment or WITH), UTF-8, at most 64 KiB, in the file named by --statement-file, then rerun with the same --idempotency-key.";
 
@@ -1203,6 +1216,8 @@ export class ProductCli {
         return await this.listDatabaseWatches(command, signal);
       if (command.kind === "database-watch-delete")
         return await this.deleteDatabaseWatch(command, signal);
+      if (command.kind === "database-table-create")
+        return await this.createDatabaseTable(command, signal);
       if (command.kind === "database-webhook-create")
         return await this.createDatabaseWebhook(command, signal);
       if (command.kind === "database-webhook-list")
@@ -2009,6 +2024,22 @@ export class ProductCli {
     return success("database watch delete", { status: "succeeded", deleted });
   }
 
+  /** The columns file and the key are checked before any request; a repeat answers the same table with created false. */
+  private async createDatabaseTable(
+    command: Extract<ProductCliCommand, { kind: "database-table-create" }>,
+    signal: AbortSignal,
+  ): Promise<CliResult> {
+    const request = await tableCreateRequest(command);
+    const api = await this.authenticatedApi(command.credentialStore, signal);
+    const answer = await api.createProjectDatabaseTable({
+      projectId: command.projectId,
+      environment: command.environment,
+      idempotencyKey: command.idempotencyKey,
+      request,
+    });
+    return success("database table create", { status: "succeeded", table: answer.table });
+  }
+
   /** The signing secret is returned by create only; every other answer carries no secret. */
   private async createDatabaseWebhook(
     command: Extract<ProductCliCommand, { kind: "database-webhook-create" }>,
@@ -3479,6 +3510,49 @@ const scheduleSetRequest = async (
   }
 };
 
+/**
+ * The table of `database table create`: the columns file is a UTF-8 JSON array, and the table, the
+ * columns and the key are checked by the contract the service uses. A refused file sends nothing.
+ */
+const tableCreateRequest = async (
+  command: Extract<ProductCliCommand, { kind: "database-table-create" }>,
+): Promise<DatabaseTableCreateInput> => {
+  const columnsFailure = () =>
+    new ProductCliFailure(2, "columns_file_invalid", false, COLUMNS_FILE_INVALID_ACTION);
+  const columns = await readBoundedUtf8File(command.columnsFile, 65_536, columnsFailure).then(
+    (text: string): unknown => {
+      try {
+        return JSON.parse(text) as unknown;
+      } catch {
+        throw columnsFailure();
+      }
+    },
+  );
+  try {
+    const parsed = parseDatabaseTableCreateRequest({
+      table: command.table,
+      columns,
+      ...(command.primaryKey.length === 0 ? {} : { primaryKey: command.primaryKey }),
+    });
+    return {
+      table: parsed.table,
+      columns: parsed.columns.map(tableColumnInput),
+      primaryKey: parsed.primaryKey,
+    };
+  } catch {
+    throw columnsFailure();
+  }
+};
+
+/** The checked column as the REST body names it; a default that is not set is left out, not sent as null. */
+const tableColumnInput = (column: DatabaseTableColumn): DatabaseTableColumnInput => ({
+  name: column.name,
+  type: column.type,
+  nullable: column.nullable,
+  identity: column.identity,
+  ...(column.default === null ? {} : { default: column.default }),
+});
+
 const psqlUnavailable = (): CliResult =>
   failure(
     "database psql",
@@ -3586,6 +3660,7 @@ const parsedCommandName = (command: ProductCliCommand): CommandLabel => {
   if (command.kind === "database-watch-create") return "database watch create";
   if (command.kind === "database-watch-list") return "database watch list";
   if (command.kind === "database-watch-delete") return "database watch delete";
+  if (command.kind === "database-table-create") return "database table create";
   if (command.kind === "database-webhook-create") return "database webhook create";
   if (command.kind === "database-webhook-list") return "database webhook list";
   if (command.kind === "database-webhook-get") return "database webhook get";

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

@@ -13,6 +13,10 @@ import {
   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,
@@ -416,6 +420,17 @@ export type ProductCliCommand =
       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;
@@ -1033,6 +1048,7 @@ export type RecognizedCommandLabel =
   | "database watch create"
   | "database watch list"
   | "database watch delete"
+  | "database table create"
   | "database webhook create"
   | "database webhook list"
   | "database webhook get"
@@ -1209,6 +1225,8 @@ export const recognizedCommandLabel = (argv: readonly string[]): RecognizedComma
       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";
@@ -2184,6 +2202,51 @@ export const parseProductCliCommand = (argv: readonly string[]): ProductCliComma
     }
     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,
@@ -162,6 +169,7 @@ import {
   createProjectDatabaseWatch,
   listProjectDatabaseWatches,
   deleteProjectDatabaseWatch,
+  createProjectDatabaseTable,
   listProjectDatabaseWebhookDeliveries,
   replayProjectDatabaseWebhookDelivery,
   setProjectDatabaseSchedule,
@@ -215,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: {
@@ -376,6 +417,12 @@ export interface ProductApi {
     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";
@@ -593,9 +640,54 @@ 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;
@@ -973,6 +1065,30 @@ export class GeneratedSdkProductApi implements ProductApi {
     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],

package/src/packages/contracts/package.json

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