zinkee 0.1.44 → 0.1.46

package/src/commands/schemas.ts

@@ -1,890 +0,0 @@
-import { readFileSync } from "node:fs";
-import type { Writable } from "node:stream";
-
-import { Command, InvalidArgumentError } from "commander";
-
-import {
-  SchemasApi,
-  type ApiSchema,
-  type ApiSchemaField,
-  type CreateSchemaFieldInput,
-  type CreateSchemaInput,
-  type SetUniqueFieldsInput,
-  type UpdateSchemaFieldInput,
-  type UpdateSchemaInput,
-} from "../api/schemas.js";
-import { ApiClientError, ApiClient } from "../client.js";
-import { defaultConfigPath, readRuntimeConfig } from "../config.js";
-import {
-  normalizeUuidOrSlug,
-  type NormalizedUuidOrSlug,
-} from "../parsers/selectors.js";
-import { resolveRuntimeContext } from "../runtime-context.js";
-import type { JsonObject, RuntimeOverrides } from "../types.js";
-import { CliError } from "../utils/errors.js";
-import {
-  assertSupportedSchemaFieldType,
-  buildSchemaFieldCreateHelpText,
-  buildSchemaFieldCreateValidationMessage,
-  formatSchemaFieldTypes,
-  normalizeSchemaFieldCreatePayload,
-  normalizeSchemaFieldUpdatePayload,
-  normalizeSchemaFieldType,
-} from "../utils/schema-fields.js";
-import { buildJsonSuccess, folderColumns, FOLDER_TABLE_KEYS, printTable } from "../utils/output.js";
-
-interface CommandIo {
-  write(chunk: string): unknown;
-}
-
-export interface RegisterSchemasCommandsOptions {
-  configPath?: string;
-  stdout?: CommandIo;
-}
-
-interface GlobalOptions extends RuntimeOverrides {}
-
-interface SchemaCreateCommandOptions {
-  name: string;
-  slug: string;
-  auditable?: boolean;
-  commentable?: boolean;
-}
-
-interface SchemaUpdateCommandOptions {
-  name?: string;
-  slug?: string;
-  auditable?: boolean;
-  commentable?: boolean;
-  highlightedField?: NormalizedUuidOrSlug;
-}
-
-interface SetUniqueFieldsCommandOptions {
-  field?: NormalizedUuidOrSlug[];
-  clear?: boolean;
-}
-
-const HIGHLIGHTED_FIELD_HELP = `
-Highlighted field:
-  The schema's "main" field. The frontend uses its value as each record's
-  display name, in two places:
-    - Activity panel: the record's title in the activity side panel
-      (the panel with the record's logs and comments).
-    - Detail view: the record's name in the left-hand record list you
-      browse to open each record's form.
-`;
-
-interface FieldCreateCommandOptions {
-  type?: string;
-  slug?: string;
-  label?: string;
-  description?: string;
-  required?: boolean;
-  default?: string;
-  raw?: string;
-  rawFile?: string;
-}
-
-interface FieldUpdateCommandOptions {
-  label?: string;
-  description?: string;
-  required?: boolean;
-  default?: string;
-  raw?: string;
-  rawFile?: string;
-}
-
-function getCommandIo(stdout: CommandIo | undefined): CommandIo {
-  return stdout ?? (process.stdout as Writable);
-}
-
-function writeLine(stdout: CommandIo, value: string): void {
-  stdout.write(`${value}\n`);
-}
-
-function getGlobalOptions(command: Command): GlobalOptions {
-  return command.optsWithGlobals<GlobalOptions>();
-}
-
-function emitJson(
-  stdout: CommandIo,
-  commandName: string,
-  data: unknown,
-  configPath: string,
-): void {
-  writeLine(
-    stdout,
-    JSON.stringify(buildJsonSuccess(data, { command: commandName, configPath })),
-  );
-}
-
-function toConfigurationError(filePath: string, error: unknown): never {
-  if (error instanceof CliError) {
-    throw error;
-  }
-
-  if (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    error.code === "ENOENT"
-  ) {
-    throw new CliError("configuration_error", `Config file not found at ${filePath}.`);
-  }
-
-  if (error instanceof Error) {
-    throw new CliError("configuration_error", error.message);
-  }
-
-  throw error;
-}
-
-function createSchemasApi(
-  command: Command,
-  filePath: string,
-): { api: SchemasApi; json: boolean; profile: string; readOnly: boolean } {
-  try {
-    const config = readRuntimeConfig(filePath);
-    const runtime = resolveRuntimeContext(config, getGlobalOptions(command));
-
-    if (!runtime.baseUrl) {
-      throw new CliError(
-        "configuration_error",
-        `Resolved profile "${runtime.profile}" is missing a base URL.`,
-      );
-    }
-
-    return {
-      api: new SchemasApi(
-        new ApiClient({
-          baseUrl: runtime.baseUrl,
-          apiKey: runtime.apiKey,
-        }),
-      ),
-      json: runtime.json,
-      profile: runtime.profile,
-      readOnly: runtime.readOnly,
-    };
-  } catch (error) {
-    toConfigurationError(filePath, error);
-  }
-}
-
-function ensureWritable(
-  commandName: string,
-  readOnly: boolean,
-  commandMode: "write" | "destructive",
-): void {
-  if (readOnly) {
-    throw new CliError(
-      "command_not_allowed_in_read_only_mode",
-      `Command "${commandName}" is not allowed in read-only mode.`,
-      {
-        commandMode,
-        executionMode: "read-only",
-      },
-    );
-  }
-}
-
-function parseUuidOrSlugSelector(input: string): NormalizedUuidOrSlug {
-  try {
-    return normalizeUuidOrSlug(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid selector.";
-    throw new InvalidArgumentError(message);
-  }
-}
-
-function collectFieldSelectors(
-  value: string,
-  previous: NormalizedUuidOrSlug[] = [],
-): NormalizedUuidOrSlug[] {
-  return [...previous, parseUuidOrSlugSelector(value)];
-}
-
-function parseBooleanFlag(input: string): boolean {
-  const normalized = input.trim().toLowerCase();
-
-  if (["true", "1", "yes", "y", "on"].includes(normalized)) {
-    return true;
-  }
-
-  if (["false", "0", "no", "n", "off"].includes(normalized)) {
-    return false;
-  }
-
-  throw new InvalidArgumentError(`Expected a boolean value, received "${input}".`);
-}
-
-function isJsonObject(value: unknown): value is JsonObject {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function parseRawJsonObject(input: string, sourceLabel: string): JsonObject {
-  let parsed: unknown;
-
-  try {
-    parsed = JSON.parse(input);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid JSON.";
-    throw new CliError(
-      "invalid_cli_usage",
-      `Failed to parse JSON from ${sourceLabel}: ${message}`,
-    );
-  }
-
-  if (!isJsonObject(parsed)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      `Expected ${sourceLabel} to contain a JSON object.`,
-    );
-  }
-
-  return parsed;
-}
-
-function readRawObject(
-  raw: string | undefined,
-  rawFile: string | undefined,
-): JsonObject {
-  if (raw && rawFile) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Provide either "--raw" or "--raw-file", not both.',
-    );
-  }
-
-  if (raw) {
-    return parseRawJsonObject(raw, "--raw");
-  }
-
-  if (rawFile) {
-    let contents: string;
-
-    try {
-      contents = readFileSync(rawFile, "utf8");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unable to read file.";
-      throw new CliError(
-        "invalid_cli_usage",
-        `Failed to read raw payload from ${rawFile}: ${message}`,
-      );
-    }
-
-    return parseRawJsonObject(contents, `--raw-file ${rawFile}`);
-  }
-
-  return {};
-}
-
-function emitSchemasTable(stdout: CommandIo, schemas: readonly ApiSchema[]): void {
-  printTable(
-    schemas.map((schema) => ({
-      id: schema.id ?? "",
-      name: schema.name ?? "",
-      slug: schema.slug ?? "",
-      auditable: schema.auditable ?? "",
-      commentable: schema.commentable ?? "",
-      ...folderColumns(schema.folder),
-    })),
-    ["id", "name", "slug", "auditable", "commentable", ...FOLDER_TABLE_KEYS],
-    stdout,
-  );
-}
-
-function emitFieldsTable(stdout: CommandIo, fields: readonly ApiSchemaField[]): void {
-  printTable(
-    fields.map((field) => ({
-      id: field.id ?? "",
-      type: field.type ?? "",
-      slug: field.slug ?? "",
-      label: field.label ?? "",
-      required: field.required ?? "",
-    })),
-    ["id", "type", "slug", "label", "required"],
-    stdout,
-  );
-}
-
-function buildSchemaUpdateInput(options: SchemaUpdateCommandOptions): UpdateSchemaInput {
-  const input: UpdateSchemaInput = {};
-
-  if (options.name !== undefined) {
-    input.name = options.name;
-  }
-
-  if (options.slug !== undefined) {
-    input.slug = options.slug;
-  }
-
-  if (options.auditable !== undefined) {
-    input.auditable = options.auditable;
-  }
-
-  if (options.commentable !== undefined) {
-    input.commentable = options.commentable;
-  }
-
-  return input;
-}
-
-function applyFieldDefaultValue(
-  input: CreateSchemaFieldInput | UpdateSchemaFieldInput,
-  defaultValue: string | undefined,
-): void {
-  if (defaultValue === undefined) {
-    return;
-  }
-
-  const config = input.config;
-
-  if (config !== undefined && !isJsonObject(config)) {
-    throw new CliError(
-      "invalid_cli_usage",
-      'Expected field "config" to be a JSON object when using "--default".',
-    );
-  }
-
-  input.config = {
-    ...(config ?? {}),
-    defaultValue,
-  };
-}
-
-function buildFieldCreateInput(
-  options: FieldCreateCommandOptions,
-): CreateSchemaFieldInput {
-  const raw = normalizeSchemaFieldCreatePayload(readRawObject(options.raw, options.rawFile));
-  const rawType = typeof raw.type === "string" ? raw.type : undefined;
-  const rawSlug = typeof raw.slug === "string" ? raw.slug : undefined;
-  const rawLabel = typeof raw.label === "string" ? raw.label : undefined;
-  const type = options.type ?? rawType;
-  const slug = options.slug ?? rawSlug;
-  const label = options.label ?? rawLabel;
-
-  if (!type) {
-    throw new CliError("invalid_cli_usage", 'Provide field type via "--type" or "--raw".');
-  }
-
-  if (!slug) {
-    throw new CliError("invalid_cli_usage", 'Provide field slug via "--slug" or "--raw".');
-  }
-
-  if (!label) {
-    throw new CliError("invalid_cli_usage", 'Provide field label via "--label" or "--raw".');
-  }
-
-  const normalizedType = normalizeSchemaFieldType(type);
-  assertSupportedSchemaFieldType(normalizedType);
-  const input: CreateSchemaFieldInput = {
-    ...raw,
-    type: normalizedType,
-    slug,
-    label,
-  };
-
-  if (options.required !== undefined) {
-    input.required = options.required;
-  }
-
-  if (options.description !== undefined) {
-    input.description = options.description;
-  }
-
-  applyFieldDefaultValue(input, options.default);
-
-  if ("config" in input && isJsonObject(input.config) && isEmptyObject(input.config)) {
-    delete input.config;
-  }
-
-  return input;
-}
-
-function readBackendErrorMessage(error: ApiClientError): string | undefined {
-  const responseBody =
-    typeof error.responseBody === "object" && error.responseBody !== null
-      ? error.responseBody
-      : undefined;
-  const envelopeError =
-    responseBody && "error" in responseBody && typeof responseBody.error === "object" && responseBody.error !== null
-      ? responseBody.error
-      : responseBody;
-
-  return (
-    (envelopeError && "message" in envelopeError && typeof envelopeError.message === "string"
-      ? envelopeError.message
-      : undefined) ??
-    (typeof error.responseText === "string" && error.responseText.length > 0
-      ? error.responseText
-      : undefined)
-  );
-}
-
-function toFieldCreateError(
-  error: unknown,
-  input: CreateSchemaFieldInput,
-): never {
-  if (!(error instanceof ApiClientError)) {
-    throw error;
-  }
-
-  const backendMessage = readBackendErrorMessage(error);
-  const isGenericValidationMessage =
-    backendMessage === "Schema payload is invalid. One or more fields are invalid." ||
-    backendMessage === "Create field payload is invalid.";
-
-  if (!isGenericValidationMessage) {
-    throw error;
-  }
-
-  throw new CliError(
-    "invalid_cli_usage",
-    buildSchemaFieldCreateValidationMessage(input.type),
-    {
-      fieldType: input.type,
-      status: error.status,
-    },
-  );
-}
-
-function buildFieldUpdateInput(
-  currentType: string,
-  options: FieldUpdateCommandOptions,
-): UpdateSchemaFieldInput {
-  const input: UpdateSchemaFieldInput = {
-    ...normalizeSchemaFieldUpdatePayload(
-      currentType,
-      readRawObject(options.raw, options.rawFile),
-    ),
-    type: currentType,
-  };
-
-  if (options.label !== undefined) {
-    input.label = options.label;
-  }
-
-  if (options.required !== undefined) {
-    input.required = options.required;
-  }
-
-  if (options.description !== undefined) {
-    input.description = options.description;
-  }
-
-  applyFieldDefaultValue(input, options.default);
-
-  return input;
-}
-
-async function resolveSchemaSelector(
-  api: SchemasApi,
-  selector: NormalizedUuidOrSlug,
-): Promise<NormalizedUuidOrSlug> {
-  if (selector.kind === "uuid") {
-    return selector;
-  }
-
-  const schemas = await api.listSchemas();
-  const match = schemas.find((schema) => schema.slug === selector.value);
-
-  if (!match || typeof match.id !== "string") {
-    throw new CliError("invalid_cli_usage", `Schema "${selector.value}" not found.`);
-  }
-
-  return {
-    kind: "uuid",
-    value: match.id,
-  };
-}
-
-async function resolveFieldSelector(
-  api: SchemasApi,
-  schema: NormalizedUuidOrSlug,
-  selector: NormalizedUuidOrSlug,
-): Promise<NormalizedUuidOrSlug> {
-  if (selector.kind === "uuid") {
-    return selector;
-  }
-
-  const fields = await api.listFields(schema);
-  const match = fields.find((field) => field.slug === selector.value);
-
-  if (!match || typeof match.id !== "string") {
-    throw new CliError("invalid_cli_usage", `Field "${selector.value}" not found.`);
-  }
-
-  return {
-    kind: "uuid",
-    value: match.id,
-  };
-}
-
-function isEmptyObject(value: object): boolean {
-  return Object.keys(value).length === 0;
-}
-
-export function registerSchemasCommands(
-  program: Command,
-  options: RegisterSchemasCommandsOptions = {},
-): void {
-  const filePath = options.configPath ?? defaultConfigPath;
-  const stdout = getCommandIo(options.stdout);
-  const schemas = program.command("schemas").description("Manage schemas and schema fields");
-
-  schemas
-    .command("list")
-    .description("List schemas")
-    .action(async function action(this: Command) {
-      const { api, json } = createSchemasApi(this, filePath);
-      const data = await api.listSchemas();
-
-      if (json) {
-        emitJson(stdout, "schemas list", data, filePath);
-        return;
-      }
-
-      emitSchemasTable(stdout, data);
-    });
-
-  schemas
-    .command("get")
-    .description("Get a schema by UUID or slug")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, schema: NormalizedUuidOrSlug) {
-      const { api, json } = createSchemasApi(this, filePath);
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      const data = await api.getSchema(resolvedSchema);
-
-      if (json) {
-        emitJson(stdout, "schemas get", data, filePath);
-        return;
-      }
-
-      emitSchemasTable(stdout, [data]);
-    });
-
-  schemas
-    .command("create")
-    .description("Create a schema")
-    .requiredOption("--name <name>", "schema name")
-    .requiredOption("--slug <slug>", "schema slug")
-    .option("--auditable", "mark schema as auditable")
-    .option("--commentable", "mark schema as commentable")
-    .action(async function action(
-      this: Command,
-      commandOptions: SchemaCreateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas create", readOnly, "write");
-
-      const input: CreateSchemaInput = {
-        name: commandOptions.name,
-        slug: commandOptions.slug,
-        auditable: Boolean(commandOptions.auditable),
-        commentable: Boolean(commandOptions.commentable),
-      };
-      const data = await api.createSchema(input);
-
-      if (json) {
-        emitJson(stdout, "schemas create", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Created schema "${data.slug ?? commandOptions.slug}".`);
-    });
-
-  schemas
-    .command("update")
-    .description("Update a schema")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .option("--name <name>", "schema name")
-    .option("--slug <slug>", "schema slug")
-    .option("--auditable <bool>", "auditable flag", parseBooleanFlag)
-    .option("--commentable <bool>", "commentable flag", parseBooleanFlag)
-    .option(
-      "--highlighted-field <field>",
-      "its value is used as each record's display name in the UI (field uuid or slug)",
-      parseUuidOrSlugSelector,
-    )
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      commandOptions: SchemaUpdateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas update", readOnly, "write");
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-
-      const input = buildSchemaUpdateInput(commandOptions);
-
-      if (commandOptions.highlightedField !== undefined) {
-        const resolvedField = await resolveFieldSelector(
-          api,
-          resolvedSchema,
-          commandOptions.highlightedField,
-        );
-        input.highlightedField = resolvedField.value;
-      }
-
-      if (isEmptyObject(input)) {
-        throw new CliError(
-          "invalid_cli_usage",
-          'Provide at least one schema field to update via "--name", "--slug", "--auditable", "--commentable", or "--highlighted-field".',
-        );
-      }
-
-      const data = await api.updateSchema(resolvedSchema, input);
-
-      if (json) {
-        emitJson(stdout, "schemas update", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated schema "${data.slug ?? schema.value}".`);
-    })
-    .addHelpText("after", HIGHLIGHTED_FIELD_HELP);
-
-  schemas
-    .command("set-unique-fields")
-    .description("Set or clear the composite unique-field constraint on a schema")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .option(
-      "--field <field>",
-      "field uuid or slug to include in the unique constraint (repeatable)",
-      collectFieldSelectors,
-      [],
-    )
-    .option("--clear", "clear the unique constraint (sends an empty field list)")
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      commandOptions: SetUniqueFieldsCommandOptions,
-    ) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas set-unique-fields", readOnly, "write");
-
-      const selectors = commandOptions.field ?? [];
-
-      if (commandOptions.clear && selectors.length > 0) {
-        throw new CliError(
-          "invalid_cli_usage",
-          'Use either "--field" or "--clear", not both.',
-        );
-      }
-
-      if (!commandOptions.clear && selectors.length === 0) {
-        throw new CliError(
-          "invalid_cli_usage",
-          'Provide at least one field via "--field", or pass "--clear" to remove the unique constraint.',
-        );
-      }
-
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      const resolvedFields = await Promise.all(
-        selectors.map((selector) => resolveFieldSelector(api, resolvedSchema, selector)),
-      );
-      const input: SetUniqueFieldsInput = {
-        fieldIds: resolvedFields.map((field) => field.value),
-      };
-
-      const data = await api.setUniqueFields(resolvedSchema, input);
-
-      if (json) {
-        emitJson(stdout, "schemas set-unique-fields", data, filePath);
-        return;
-      }
-
-      if (input.fieldIds.length === 0) {
-        writeLine(stdout, `Cleared unique fields on schema "${schema.value}".`);
-        return;
-      }
-
-      const count = input.fieldIds.length;
-      writeLine(
-        stdout,
-        `Set unique fields on schema "${schema.value}" (${count} field${count === 1 ? "" : "s"}).`,
-      );
-    });
-
-  schemas
-    .command("delete")
-    .description("Delete a schema")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, schema: NormalizedUuidOrSlug) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas delete", readOnly, "destructive");
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-
-      await api.deleteSchema(resolvedSchema);
-      const data = {
-        schema: resolvedSchema.value,
-        deleted: true,
-      };
-
-      if (json) {
-        emitJson(stdout, "schemas delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted schema "${schema.value}".`);
-    });
-
-  const fields = schemas.command("fields").description("Manage schema fields");
-
-  fields
-    .command("list")
-    .description("List fields for a schema")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .action(async function action(this: Command, schema: NormalizedUuidOrSlug) {
-      const { api, json } = createSchemasApi(this, filePath);
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      const data = await api.listFields(resolvedSchema);
-
-      if (json) {
-        emitJson(stdout, "schemas fields list", data, filePath);
-        return;
-      }
-
-      emitFieldsTable(stdout, data);
-    });
-
-  fields
-    .command("get")
-    .description("Get a field by UUID or slug")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .argument("<field>", "field uuid or slug", parseUuidOrSlugSelector)
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      field: NormalizedUuidOrSlug,
-    ) {
-      const { api, json } = createSchemasApi(this, filePath);
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
-      const data = await api.getField(resolvedSchema, resolvedField);
-
-      if (json) {
-        emitJson(stdout, "schemas fields get", data, filePath);
-        return;
-      }
-
-      emitFieldsTable(stdout, [data]);
-    });
-
-  fields
-    .command("create")
-    .description(`Create a field in a schema.${buildSchemaFieldCreateHelpText()}`)
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .option("--type <type>", `field type (${formatSchemaFieldTypes()})`)
-    .option("--slug <slug>", "field slug")
-    .option("--label <label>", "field label")
-    .option("--description <text>", "field description")
-    .option("--required <bool>", "required flag", parseBooleanFlag)
-    .option("--default <value>", "default field value")
-    .option("--raw <json>", 'raw JSON object payload (see type-specific shapes in --help)')
-    .option("--raw-file <path>", "path to a raw JSON object payload")
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      commandOptions: FieldCreateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas fields create", readOnly, "write");
-      const input = buildFieldCreateInput(commandOptions);
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      let data: ApiSchemaField;
-      try {
-        data = await api.createField(resolvedSchema, input);
-      } catch (error) {
-        toFieldCreateError(error, input);
-      }
-
-      if (json) {
-        emitJson(stdout, "schemas fields create", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Created field "${data.slug ?? commandOptions.slug}".`);
-    });
-
-  fields
-    .command("update")
-    .description("Update a field in a schema")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .argument("<field>", "field uuid or slug", parseUuidOrSlugSelector)
-    .option("--label <label>", "field label")
-    .option("--description <text>", 'field description (use "" to clear)')
-    .option("--required <bool>", "required flag", parseBooleanFlag)
-    .option("--default <value>", "default field value")
-    .option("--raw <json>", "raw JSON object payload")
-    .option("--raw-file <path>", "path to a raw JSON object payload")
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      field: NormalizedUuidOrSlug,
-      commandOptions: FieldUpdateCommandOptions,
-    ) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas fields update", readOnly, "write");
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
-      const currentField = await api.getField(resolvedSchema, resolvedField);
-      const currentType =
-        typeof currentField.type === "string" && currentField.type.length > 0
-          ? currentField.type
-          : undefined;
-
-      if (!currentType) {
-        throw new CliError("invalid_cli_usage", `Field "${field.value}" is missing type metadata.`);
-      }
-
-      const input = buildFieldUpdateInput(currentType, commandOptions);
-
-      if (isEmptyObject(input)) {
-        throw new CliError(
-          "invalid_cli_usage",
-          'Provide at least one field update via "--label", "--description", "--required", "--default", "--raw", or "--raw-file".',
-        );
-      }
-
-      const data = await api.updateField(resolvedSchema, resolvedField, input);
-
-      if (json) {
-        emitJson(stdout, "schemas fields update", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Updated field "${data.slug ?? field.value}".`);
-    });
-
-  fields
-    .command("delete")
-    .description("Delete a field from a schema")
-    .argument("<schema>", "schema uuid or slug", parseUuidOrSlugSelector)
-    .argument("<field>", "field uuid or slug", parseUuidOrSlugSelector)
-    .action(async function action(
-      this: Command,
-      schema: NormalizedUuidOrSlug,
-      field: NormalizedUuidOrSlug,
-    ) {
-      const { api, json, readOnly } = createSchemasApi(this, filePath);
-      ensureWritable("schemas fields delete", readOnly, "destructive");
-      const resolvedSchema = await resolveSchemaSelector(api, schema);
-      const resolvedField = await resolveFieldSelector(api, resolvedSchema, field);
-
-      await api.deleteField(resolvedSchema, resolvedField);
-      const data = {
-        schema: resolvedSchema.value,
-        field: resolvedField.value,
-        deleted: true,
-      };
-
-      if (json) {
-        emitJson(stdout, "schemas fields delete", data, filePath);
-        return;
-      }
-
-      writeLine(stdout, `Deleted field "${field.value}" from schema "${schema.value}".`);
-    });
-}