zinkee 0.1.44 → 0.1.46

package/src/api/navigation.ts

@@ -1,70 +0,0 @@
-import { ApiClient } from "../client.js";
-import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
-
-export interface NavigationFolder {
-  id: string;
-  order?: number;
-  name?: string;
-  resources?: Array<Record<string, unknown>>;
-  additionalProperties?: Record<string, unknown>;
-}
-
-export interface NavigationFolderMutation {
-  folderId?: string;
-  name?: string;
-}
-
-export interface NavigationMoveResourceInput {
-  resourceId: string;
-  targetFolderId: string;
-}
-
-function jsonOptions(body: unknown, method: string): RequestInit {
-  return {
-    method,
-    headers: {
-      "content-type": "application/json",
-    },
-    body: JSON.stringify(body),
-  };
-}
-
-function selectorValue(selector: NormalizedUuidOrSlug): string {
-  return selector.value;
-}
-
-export class NavigationApi {
-  constructor(private readonly client: ApiClient) {}
-
-  listFolders(): Promise<NavigationFolder[]> {
-    return this.client.getJson<NavigationFolder[]>("/api/v2/navigation/folders");
-  }
-
-  createFolder(body: Record<string, unknown>): Promise<NavigationFolderMutation> {
-    return this.client.requestJson<NavigationFolderMutation>(
-      "/api/v2/navigation/folders",
-      jsonOptions(body, "POST"),
-    );
-  }
-
-  updateFolder(folder: NormalizedUuidOrSlug, body: Record<string, unknown>): Promise<NavigationFolderMutation> {
-    return this.client.requestJson<NavigationFolderMutation>(
-      `/api/v2/navigation/folders/${selectorValue(folder)}`,
-      jsonOptions(body, "PATCH"),
-    );
-  }
-
-  deleteFolder(folder: NormalizedUuidOrSlug): Promise<NavigationFolderMutation> {
-    return this.client.requestJson<NavigationFolderMutation>(
-      `/api/v2/navigation/folders/${selectorValue(folder)}`,
-      { method: "DELETE" },
-    );
-  }
-
-  moveResource(body: NavigationMoveResourceInput): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      "/api/v2/navigation/resources:move",
-      jsonOptions(body, "POST"),
-    );
-  }
-}

package/src/api/records.ts

@@ -1,184 +0,0 @@
-import { ApiClient } from "../client.js";
-import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
-
-export interface ApiRecord {
-  [key: string]: unknown;
-  recordId?: string;
-  values?: Record<string, unknown>;
-}
-
-export interface RecordQueryExpression {
-  field: string;
-  comparator: string;
-  value: unknown;
-}
-
-export interface RecordQuerySort {
-  field: string;
-  direction: "ASC" | "DESC";
-}
-
-export interface RecordQueryResult {
-  records: ApiRecord[];
-  page?: Record<string, unknown>;
-}
-
-export interface RecordQueryInput {
-  [key: string]: unknown;
-  select?: string[];
-  where?: RecordQueryExpression[];
-  search?: { term: string };
-  sort?: string[];
-  limit?: number;
-  offset?: number;
-}
-
-export type CreateRecordValues = Record<string, unknown>;
-
-export interface CreateRecordError {
-  index: number;
-  reason: string;
-  message: string;
-  action: string;
-}
-
-export interface CreateRecordsResult {
-  created: string[];
-  errors: CreateRecordError[];
-}
-
-export interface UpdateRecordInput {
-  set?: Record<string, unknown>;
-  unset?: string[];
-}
-
-function jsonOptions(body: unknown, method: string): RequestInit {
-  return {
-    method,
-    headers: {
-      "content-type": "application/json",
-    },
-    body: JSON.stringify(body),
-  };
-}
-
-function selectorValue(selector: NormalizedUuidOrSlug): string {
-  return selector.value;
-}
-
-export class RecordsApi {
-  constructor(private readonly client: ApiClient) {}
-
-  listRecords(
-    schema: NormalizedUuidOrSlug,
-    query: RecordQueryInput,
-  ): Promise<RecordQueryResult> {
-    const params = new URLSearchParams();
-
-    if (query.limit !== undefined) {
-      params.set("limit", String(query.limit));
-    }
-
-    if (query.offset !== undefined) {
-      params.set("offset", String(query.offset));
-    }
-
-    const path = `/api/v2/schemas/${selectorValue(schema)}/records`;
-    const queryString = params.toString();
-
-    return this.client.getJson<RecordQueryResult>(
-      queryString ? `${path}?${queryString}` : path,
-    );
-  }
-
-  queryRecords(
-    schema: NormalizedUuidOrSlug,
-    query: RecordQueryInput,
-  ): Promise<RecordQueryResult> {
-    const body = this.normalizeQueryInput(query);
-
-    return this.client.requestJson<RecordQueryResult>(
-      `/api/v2/schemas/${selectorValue(schema)}/records:query`,
-      jsonOptions(body, "POST"),
-    );
-  }
-
-  getRecord(
-    schema: NormalizedUuidOrSlug,
-    record: NormalizedUuidOrSlug,
-  ): Promise<ApiRecord> {
-    return this.client.getJson<ApiRecord>(
-      `/api/v2/schemas/${selectorValue(schema)}/records/${selectorValue(record)}`,
-    );
-  }
-
-  createRecords(
-    schema: NormalizedUuidOrSlug,
-    records: CreateRecordValues[],
-  ): Promise<CreateRecordsResult> {
-    return this.client.requestJson<CreateRecordsResult>(
-      `/api/v2/schemas/${selectorValue(schema)}/records`,
-      jsonOptions({ records }, "POST"),
-    );
-  }
-
-  updateRecord(
-    schema: NormalizedUuidOrSlug,
-    record: NormalizedUuidOrSlug,
-    input: UpdateRecordInput,
-  ): Promise<ApiRecord> {
-    return this.client.requestJson<ApiRecord>(
-      `/api/v2/schemas/${selectorValue(schema)}/records/${selectorValue(record)}`,
-      jsonOptions(input, "PATCH"),
-    );
-  }
-
-  deleteRecords(
-    schema: NormalizedUuidOrSlug,
-    recordIds: string[],
-  ): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      `/api/v2/schemas/${selectorValue(schema)}/records:delete`,
-      jsonOptions({ recordIds }, "POST"),
-    );
-  }
-
-  clearRecords(schema: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      `/api/v2/schemas/${selectorValue(schema)}/records:clear`,
-      { method: "DELETE" },
-    );
-  }
-
-  private normalizeQueryInput(query: RecordQueryInput): Record<string, unknown> {
-    const where = query.where?.map((expression) => ({
-      field: expression.field,
-      op: expression.comparator,
-      value: expression.value,
-    }));
-
-    const sort = query.sort?.map((entry) => {
-      const [field, direction = "asc"] = entry.split(":");
-      return {
-        field,
-        direction: direction.toUpperCase(),
-      };
-    });
-
-    return {
-      ...query,
-      select: query.select,
-      where,
-      sort,
-      page:
-        query.limit !== undefined || query.offset !== undefined
-          ? {
-              offset: query.offset,
-              limit: query.limit,
-            }
-          : undefined,
-      limit: undefined,
-      offset: undefined,
-    };
-  }
-}

package/src/api/schemas.ts

@@ -1,148 +0,0 @@
-import { ApiClient } from "../client.js";
-import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
-
-export interface ApiSchemaField {
-  [key: string]: unknown;
-  id?: string;
-  type?: string;
-  slug?: string;
-  label?: string;
-  description?: string;
-  required?: boolean;
-}
-
-export interface ApiSchema {
-  [key: string]: unknown;
-  id?: string;
-  name?: string;
-  slug?: string;
-  auditable?: boolean;
-  commentable?: boolean;
-  highlightedField?: string;
-  fields?: ApiSchemaField[];
-  uniqueFields?: string[];
-  folder?: { id?: string; name?: string | null; isRoot?: boolean };
-}
-
-export interface CreateSchemaInput {
-  name: string;
-  slug: string;
-  auditable?: boolean;
-  commentable?: boolean;
-}
-
-export interface UpdateSchemaInput {
-  name?: string;
-  slug?: string;
-  auditable?: boolean;
-  commentable?: boolean;
-  highlightedField?: string;
-}
-
-export interface SetUniqueFieldsInput {
-  fieldIds: string[];
-}
-
-export interface CreateSchemaFieldInput {
-  [key: string]: unknown;
-  type: string;
-  slug: string;
-  label: string;
-  description?: string;
-  required?: boolean;
-}
-
-export interface UpdateSchemaFieldInput {
-  [key: string]: unknown;
-  label?: string;
-  description?: string;
-  required?: boolean;
-}
-
-function jsonOptions(body: unknown, method: string): RequestInit {
-  return {
-    method,
-    headers: {
-      "content-type": "application/json",
-    },
-    body: JSON.stringify(body),
-  };
-}
-
-function selectorValue(selector: NormalizedUuidOrSlug): string {
-  return selector.value;
-}
-
-export class SchemasApi {
-  constructor(private readonly client: ApiClient) {}
-
-  listSchemas(): Promise<ApiSchema[]> {
-    return this.client.getJson<ApiSchema[]>("/api/v2/schemas");
-  }
-
-  getSchema(schema: NormalizedUuidOrSlug): Promise<ApiSchema> {
-    return this.client.getJson<ApiSchema>(`/api/v2/schemas/${selectorValue(schema)}`);
-  }
-
-  createSchema(input: CreateSchemaInput): Promise<ApiSchema> {
-    return this.client.requestJson<ApiSchema>("/api/v2/schemas", jsonOptions(input, "POST"));
-  }
-
-  updateSchema(schema: NormalizedUuidOrSlug, input: UpdateSchemaInput): Promise<ApiSchema> {
-    return this.client.requestJson<ApiSchema>(
-      `/api/v2/schemas/${selectorValue(schema)}`,
-      jsonOptions(input, "PATCH"),
-    );
-  }
-
-  setUniqueFields(schema: NormalizedUuidOrSlug, input: SetUniqueFieldsInput): Promise<ApiSchema> {
-    return this.client.requestJson<ApiSchema>(
-      `/api/v2/schemas/${selectorValue(schema)}/unique-fields`,
-      jsonOptions(input, "PUT"),
-    );
-  }
-
-  deleteSchema(schema: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      `/api/v2/schemas/${selectorValue(schema)}`,
-      { method: "DELETE" },
-    );
-  }
-
-  async listFields(schema: NormalizedUuidOrSlug): Promise<ApiSchemaField[]> {
-    const result = await this.getSchema(schema);
-
-    return Array.isArray(result.fields) ? result.fields : [];
-  }
-
-  getField(schema: NormalizedUuidOrSlug, field: NormalizedUuidOrSlug): Promise<ApiSchemaField> {
-    return this.client.getJson<ApiSchemaField>(
-      `/api/v2/schemas/${selectorValue(schema)}/fields/${selectorValue(field)}`,
-    );
-  }
-
-  createField(schema: NormalizedUuidOrSlug, input: CreateSchemaFieldInput): Promise<ApiSchemaField> {
-    return this.client.requestJson<ApiSchemaField>(
-      `/api/v2/schemas/${selectorValue(schema)}/fields`,
-      jsonOptions(input, "POST"),
-    );
-  }
-
-  updateField(
-    schema: NormalizedUuidOrSlug,
-    field: NormalizedUuidOrSlug,
-    input: UpdateSchemaFieldInput,
-  ): Promise<ApiSchemaField> {
-    return this.client.requestJson<ApiSchemaField>(
-      `/api/v2/schemas/${selectorValue(schema)}/fields/${selectorValue(field)}`,
-      jsonOptions(input, "PATCH"),
-    );
-  }
-
-  deleteField(schema: NormalizedUuidOrSlug, field: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      `/api/v2/schemas/${selectorValue(schema)}/fields/${selectorValue(field)}`,
-      { method: "DELETE" },
-    );
-  }
-}

package/src/api/teamspace.ts

@@ -1,110 +0,0 @@
-import { ApiClient } from "../client.js";
-import type { NormalizedUuidOrSlug } from "../parsers/selectors.js";
-import type { JsonObject } from "../types.js";
-
-export interface ApiTeamspaceResource {
-  [key: string]: unknown;
-  id?: string;
-  name?: string;
-}
-
-export interface ApiTeamspaceFolder {
-  [key: string]: unknown;
-  id?: string;
-  name?: string;
-  order?: number;
-  additionalProperties?: JsonObject;
-  resources?: ApiTeamspaceResource[];
-}
-
-export interface CreateTeamspaceFolderInput {
-  [key: string]: unknown;
-  name: string;
-  order?: number;
-  additionalProperties?: JsonObject;
-}
-
-export interface UpdateTeamspaceFolderInput {
-  [key: string]: unknown;
-  name?: string;
-  order?: number;
-  additionalProperties?: JsonObject;
-}
-
-export interface PublishTeamspaceResourceInput {
-  resourceId: string;
-  targetFolderId: string;
-}
-
-function jsonOptions(body: unknown, method: string): RequestInit {
-  return {
-    method,
-    headers: {
-      "content-type": "application/json",
-    },
-    body: JSON.stringify(body),
-  };
-}
-
-function selectorValue(selector: NormalizedUuidOrSlug): string {
-  return selector.value;
-}
-
-export class TeamspaceApi {
-  constructor(private readonly client: ApiClient) {}
-
-  listFolders(includeResources: boolean = false): Promise<ApiTeamspaceFolder[]> {
-    const params = new URLSearchParams();
-
-    if (includeResources) {
-      params.set("include", "resources");
-    }
-
-    const path = "/api/v2/teamspaces/folders";
-    const queryString = params.toString();
-
-    return this.client.getJson<ApiTeamspaceFolder[]>(
-      queryString ? `${path}?${queryString}` : path,
-    );
-  }
-
-  createFolder(input: CreateTeamspaceFolderInput): Promise<ApiTeamspaceFolder> {
-    return this.client.requestJson<ApiTeamspaceFolder>(
-      "/api/v2/teamspaces/folders",
-      jsonOptions(input, "POST"),
-    );
-  }
-
-  updateFolder(
-    folder: NormalizedUuidOrSlug,
-    input: UpdateTeamspaceFolderInput,
-  ): Promise<ApiTeamspaceFolder> {
-    return this.client.requestJson<ApiTeamspaceFolder>(
-      `/api/v2/teamspaces/folders/${selectorValue(folder)}`,
-      jsonOptions(input, "PATCH"),
-    );
-  }
-
-  deleteFolder(folder: NormalizedUuidOrSlug): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      `/api/v2/teamspaces/folders/${selectorValue(folder)}`,
-      { method: "DELETE" },
-    );
-  }
-
-  publishResource(
-    input: PublishTeamspaceResourceInput,
-  ): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      "/api/v2/teamspaces/resources:publish",
-      jsonOptions(input, "POST"),
-    );
-  }
-
-  unpublishResource(resourceId: string): Promise<Record<string, unknown>> {
-    return this.client.requestJson<Record<string, unknown>>(
-      "/api/v2/teamspaces/resources:unpublish",
-      jsonOptions({ resourceId }, "POST"),
-    );
-  }
-}

package/src/cli-examples.ts

@@ -1,130 +0,0 @@
-import { commandRegistry } from "./command-registry.js";
-import {
-  collectOperandTokens,
-  createDefaultOptionMetadata,
-  findCommandPath,
-  type OptionMetadata,
-} from "./utils/argv-rewrite.js";
-import { CliError } from "./utils/errors.js";
-import { getResolvedCommandExamples } from "./utils/examples.js";
-import { buildJsonSuccess } from "./utils/output.js";
-
-interface CommandIo {
-  write(chunk: string): unknown;
-}
-
-export interface ExampleRequest {
-  commandName: string;
-  filters: {
-    type?: string;
-  };
-  json: boolean;
-}
-
-function getStdout(stdout?: CommandIo): CommandIo {
-  return stdout ?? process.stdout;
-}
-
-function extractExampleFilters(tokens: readonly string[]): { type?: string } {
-  const filters: { type?: string } = {};
-
-  for (let index = 0; index < tokens.length; index += 1) {
-    const token = tokens[index];
-
-    if (token === "--type") {
-      const value = tokens[index + 1];
-      if (value && !value.startsWith("-")) {
-        filters.type = value;
-        index += 1;
-      }
-    }
-  }
-
-  return filters;
-}
-
-export function extractExampleRequest(
-  argv: readonly string[],
-  optionMeta: OptionMetadata = createDefaultOptionMetadata(),
-): ExampleRequest | null {
-  if (!argv.includes("--example")) {
-    return null;
-  }
-
-  const userArgs = argv.slice(2);
-  const operands = collectOperandTokens(userArgs, optionMeta, { skipFlag: "--example" });
-  const cmdPath = findCommandPath(operands, commandRegistry);
-
-  if (!cmdPath) {
-    const typed = operands.map((operand) => operand.token).join(" ");
-
-    if (typed.length === 0) {
-      throw new CliError("invalid_cli_usage", 'Provide a command after "--example".');
-    }
-
-    // The token(s) didn't resolve to a runnable command. If they form the prefix
-    // of one or more registered commands, the user named a command group (e.g.
-    // "schemas") — list its subcommands instead of the generic error.
-    const subcommands = Object.keys(commandRegistry).filter((name) =>
-      name.startsWith(`${typed} `),
-    );
-
-    if (subcommands.length > 0) {
-      const list = subcommands.map((name) => `  zinkee --example ${name}`).join("\n");
-      throw new CliError(
-        "invalid_cli_usage",
-        `"${typed}" is a command group, not a runnable command. Available subcommands:\n${list}`,
-      );
-    }
-
-    throw new CliError("invalid_cli_usage", `Unknown command "${typed}".`);
-  }
-
-  const remainingTokens = userArgs.slice(cmdPath.lastArgvIndex + 1);
-
-  return {
-    commandName: cmdPath.commandName,
-    filters: extractExampleFilters(remainingTokens),
-    json: argv.includes("--json"),
-  };
-}
-
-export function showExamples(
-  commandName: string,
-  json: boolean,
-  stdout?: CommandIo,
-  filters: { type?: string } = {},
-): void {
-  const examples = getResolvedCommandExamples(commandName, filters);
-
-  if (examples.length === 0) {
-    throw new CliError("invalid_cli_usage", `No examples registered for "${commandName}".`);
-  }
-
-  const writer = getStdout(stdout);
-
-  if (json) {
-    writer.write(`${JSON.stringify(buildJsonSuccess({ examples }, { command: commandName }))}\n`);
-    return;
-  }
-
-  writer.write("Examples:\n");
-  for (const [index, example] of examples.entries()) {
-    writer.write(`\n${index + 1}. ${example.description}\n`);
-    writer.write(`   ${example.command}\n`);
-
-    if (example.raw) {
-      writer.write("   Equivalent JSON payload:\n");
-      for (const line of example.raw.split("\n")) {
-        writer.write(`     ${line}\n`);
-      }
-    }
-
-    if (example.response) {
-      writer.write("   Example response:\n");
-      for (const line of example.response.split("\n")) {
-        writer.write(`     ${line}\n`);
-      }
-    }
-  }
-}